fumadocs-mdx 13.0.8 → 14.0.1

package/dist/bin.cjs

@@ -30,11 +30,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// src/loaders/mdx/preset.ts
-var preset_exports = {};
-__export(preset_exports, {
-  getDefaultMDXOptions: () => getDefaultMDXOptions
-});
+// src/config/preset.ts
 function pluginOption(def, options = []) {
   const list = def(Array.isArray(options) ? options : []).filter(
     Boolean
@@ -44,76 +40,81 @@ 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"() {
+  "src/config/preset.ts"() {
     "use strict";
-    plugins = __toESM(require("fumadocs-core/mdx-plugins"), 1);
   }
 });
 
@@ -124,7 +125,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);
@@ -178,11 +182,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,
@@ -190,21 +189,22 @@ 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;
     }
   };
@@ -214,6 +214,7 @@ var init_build = __esm({
   "src/config/build.ts"() {
     "use strict";
     import_picomatch = __toESM(require("picomatch"), 1);
+    init_preset();
     SupportedFormats = {
       doc: ["mdx", "md"],
       meta: ["json", "yaml"]
@@ -226,8 +227,9 @@ var load_from_file_exports = {};
 __export(load_from_file_exports, {
   loadConfig: () => loadConfig
 });
-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,
@@ -246,56 +248,24 @@ 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)
   );
   return await config;
 }
-var path, import_node_url;
+var import_node_url;
 var init_load_from_file = __esm({
   "src/config/load-from-file.ts"() {
     "use strict";
-    path = __toESM(require("path"), 1);
     import_node_url = require("url");
     init_build();
   }
 });
 
-// src/next/file-cache.ts
-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));
-}
-var import_lru_cache, import_promises, import_node_path, map;
-var init_file_cache = __esm({
-  "src/next/file-cache.ts"() {
-    "use strict";
-    import_lru_cache = require("lru-cache");
-    import_promises = __toESM(require("fs/promises"), 1);
-    import_node_path = __toESM(require("path"), 1);
-    map = new import_lru_cache.LRUCache({
-      max: 100
-    });
-  }
-});
-
 // src/utils/validation.ts
 async function validate(schema, data, context, errorMessage) {
   if (typeof schema === "function" && !("~standard" in schema)) {
@@ -312,11 +282,10 @@ async function validate(schema, data, context, errorMessage) {
   }
   return data;
 }
-var import_picocolors, ValidationError;
+var ValidationError;
 var init_validation = __esm({
   "src/utils/validation.ts"() {
     "use strict";
-    import_picocolors = __toESM(require("picocolors"), 1);
     ValidationError = class extends Error {
       constructor(message, issues) {
         super(
@@ -326,12 +295,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");
@@ -340,32 +310,357 @@ ${issues.map((issue) => `  ${issue.path}: ${issue.message}`).join("\n")}`
   }
 });
 
-// src/utils/git-timestamp.ts
-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
+// src/utils/codegen.ts
+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(path9) {
+  const isExtendedLengthPath = path9.startsWith("\\\\?\\");
+  if (isExtendedLengthPath) {
+    return path9;
+  }
+  return path9.replaceAll("\\", "/");
+}
+function ident(code, tab = 1) {
+  return code.split("\n").map((v) => "  ".repeat(tab) + v).join("\n");
+}
+var import_node_path, import_tinyglobby;
+var init_codegen = __esm({
+  "src/utils/codegen.ts"() {
+    "use strict";
+    import_node_path = __toESM(require("path"), 1);
+    import_tinyglobby = require("tinyglobby");
+  }
+});
+
+// src/core.ts
+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 start2 = 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() - start2}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;
 }
-var import_node_path2, import_tinyexec, cache;
-var init_git_timestamp = __esm({
-  "src/utils/git-timestamp.ts"() {
+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");
+      }
+    }
+  };
+}
+var import_node_path2, import_promises, _Defaults;
+var init_core = __esm({
+  "src/core.ts"() {
     "use strict";
     import_node_path2 = __toESM(require("path"), 1);
-    import_tinyexec = require("tinyexec");
-    cache = /* @__PURE__ */ new Map();
+    import_promises = __toESM(require("fs/promises"), 1);
+    init_validation();
+    init_codegen();
+    _Defaults = {
+      configPath: "source.config.ts",
+      outDir: ".source"
+    };
+  }
+});
+
+// src/loaders/index.ts
+var metaLoaderGlob, mdxLoaderGlob;
+var init_loaders = __esm({
+  "src/loaders/index.ts"() {
+    "use strict";
+    metaLoaderGlob = /\.(json|yaml)(\?.+?)?$/;
+    mdxLoaderGlob = /\.mdx?(\?.+?)?$/;
+  }
+});
+
+// src/utils/fs-cache.ts
+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));
+}
+var import_lru_cache, import_promises2, import_node_path3, map;
+var init_fs_cache = __esm({
+  "src/utils/fs-cache.ts"() {
+    "use strict";
+    import_lru_cache = require("lru-cache");
+    import_promises2 = __toESM(require("fs/promises"), 1);
+    import_node_path3 = __toESM(require("path"), 1);
+    map = new import_lru_cache.LRUCache({
+      max: 100
+    });
   }
 });
 
@@ -391,343 +686,305 @@ var init_fuma_matter = __esm({
   }
 });
 
-// src/utils/import-formatter.ts
-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);
-  }
-  return importPath.replaceAll(import_node_path3.default.sep, "/");
-}
-function ident(code, tab = 1) {
-  return code.split("\n").map((v) => "  ".repeat(tab) + v).join("\n");
-}
-var import_node_path3;
-var init_import_formatter = __esm({
-  "src/utils/import-formatter.ts"() {
-    "use strict";
-    import_node_path3 = __toESM(require("path"), 1);
+    if (typeConfigs.length === 0) {
+      typeConfigs.push("{ DocData: {} }");
+    }
+    return {
+      serverOptions,
+      tc: typeConfigs.join(" & ")
+    };
   }
-});
-
-// src/plugins/next.ts
-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 (path9, content) => {
+        const codegen = createCodegen({
+          target,
+          outDir: this.outDir,
+          jsExtension: addJsExtension,
+          globCache
+        });
+        await content({
+          core: this.core,
+          codegen,
+          serverOptions,
+          tc
+        });
+        return {
+          path: path9,
+          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(", ")}]);`;
-    }
-    if (collection.async) {
-      return `export const ${k} = _runtimeAsync.doc<typeof _source.${k}>([${(await getAsyncEntries(collection, files)).join(", ")}], "${k}", _sourceConfig)`;
+      case "doc":
+        return `await create.doc("${collection.name}", "${collection.dir}", ${entries.join(", ")})`;
     }
-    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 extname3 = path5.extname(file);
-  try {
-    if (extname3 === ".json") return JSON.parse(content);
-    if (extname3 === ".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: ${extname3}, in ${file}.`);
-}
-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
-        });
-      }
-    })
-  );
-  return Array.from(files.values());
-}
-var path5, import_node_crypto, import_js_yaml2;
-var init_next = __esm({
-  "src/plugins/next.ts"() {
-    "use strict";
-    path5 = __toESM(require("path"), 1);
-    import_node_crypto = require("crypto");
-    init_validation();
-    init_file_cache();
-    init_git_timestamp();
-    init_fuma_matter();
-    init_import_formatter();
-    import_js_yaml2 = require("js-yaml");
   }
-});
-
-// src/core.ts
-function findConfigFile() {
-  return import_node_path4.default.resolve("source.config.ts");
+  await codegen.pushAsync(
+    core.getConfig().collectionList.map(async (collection) => {
+      const obj = await generateCollectionObject(collection);
+      if (!obj) return;
+      return `
+export const ${collection.name} = ${obj};`;
+    })
+  );
 }
-function createCore(options, defaultPlugins = []) {
-  let config;
-  let plugins2;
-  return {
-    _options: options,
-    getPluginContext() {
-      return {
-        core: this,
-        ...options
-      };
-    },
-    /**
-     * 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;
+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);
       }
-      return this;
+      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},`);
+    })
+  );
+  codegen.lines.push("};", "export default browserCollections;");
+}
+function generateDocCollectionFrontmatterGlob(codegen, collection, eager = false) {
+  return codegen.generateGlobImport(collection.patterns, {
+    query: {
+      collection: collection.name,
+      only: "frontmatter"
     },
-    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 start2 = 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() - start2}ms`);
-    }
-  };
+    import: "default",
+    base: collection.dir,
+    eager
+  });
 }
-var import_node_path4, import_promises2;
-var init_core = __esm({
-  "src/core.ts"() {
-    "use strict";
-    import_node_path4 = __toESM(require("path"), 1);
-    import_promises2 = __toESM(require("fs/promises"), 1);
-  }
-});
-
-// src/loaders/index.ts
-var metaLoaderGlob, mdxLoaderGlob;
-var init_loaders = __esm({
-  "src/loaders/index.ts"() {
+var import_path, import_tinyglobby2, import_crypto;
+var init_index_file = __esm({
+  "src/plugins/index-file.ts"() {
     "use strict";
-    metaLoaderGlob = /\.(json|yaml)(\?.+?)?$/;
-    mdxLoaderGlob = /\.mdx?(\?.+?)?$/;
+    import_path = __toESM(require("path"), 1);
+    init_codegen();
+    import_tinyglobby2 = require("tinyglobby");
+    init_fs_cache();
+    import_crypto = require("crypto");
+    init_fuma_matter();
   }
 });
 
@@ -738,15 +995,16 @@ __export(next_exports, {
   postInstall: () => postInstall
 });
 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 = {
@@ -761,6 +1019,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"
         }
       }
     };
@@ -768,42 +1044,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);
@@ -815,10 +1103,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();
@@ -838,32 +1125,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,
@@ -872,7 +1155,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);
         }
@@ -880,17 +1163,16 @@ function createNextCore({
     }
   };
 }
-var path7, defaultPageExtensions;
-var init_next2 = __esm({
+var path5, defaultPageExtensions;
+var init_next = __esm({
   "src/next/index.ts"() {
     "use strict";
-    path7 = __toESM(require("path"), 1);
+    path5 = __toESM(require("path"), 1);
     init_load_from_file();
-    init_file_cache();
     init_validation();
-    init_next();
     init_core();
     init_loaders();
+    init_index_file();
     defaultPageExtensions = ["mdx", "md", "jsx", "js", "tsx", "ts"];
   }
 });
@@ -945,6 +1227,19 @@ var init_remark_unravel = __esm({
   }
 });
 
+// src/loaders/mdx/mdast-utils.ts
+function flattenNode(node) {
+  if ("children" in node)
+    return node.children.map((child) => flattenNode(child)).join("");
+  if ("value" in node) return node.value;
+  return "";
+}
+var init_mdast_utils = __esm({
+  "src/loaders/mdx/mdast-utils.ts"() {
+    "use strict";
+  }
+});
+
 // src/loaders/mdx/remark-include.ts
 function isElementLike(node) {
   return ElementLikeTypes.includes(node.type);
@@ -961,12 +1256,6 @@ function parseElementAttributes(element) {
   }
   return element.attributes ?? {};
 }
-function flattenNode(node) {
-  if ("children" in node)
-    return node.children.map((child) => flattenNode(child)).join("");
-  if ("value" in node) return node.value;
-  return "";
-}
 function parseSpecifier(specifier) {
   const idx = specifier.lastIndexOf("#");
   if (idx === -1) return { file: specifier };
@@ -1021,7 +1310,7 @@ ${e instanceof Error ? e.message : String(e)}`,
         { cause: e }
       );
     }
-    const ext = path8.extname(file);
+    const ext = path6.extname(file);
     data._compiler?.addDependency(file);
     if (params.lang || ext !== ".md" && ext !== ".mdx") {
       const lang = params.lang ?? ext.slice(1);
@@ -1054,7 +1343,7 @@ ${e instanceof Error ? e.message : String(e)}`,
     } else {
       mdast = await baseProcessor.run(mdast);
     }
-    await update(mdast, path8.dirname(file), data);
+    await update(mdast, path6.dirname(file), data);
     return mdast;
   };
   async function update(tree, directory, data) {
@@ -1066,7 +1355,7 @@ ${e instanceof Error ? e.message : String(e)}`,
       if (specifier.length === 0) return "skip";
       const attributes = parseElementAttributes(node);
       const { file: relativePath, section } = parseSpecifier(specifier);
-      const file = path8.resolve(
+      const file = path6.resolve(
         "cwd" in attributes ? process.cwd() : directory,
         relativePath
       );
@@ -1083,20 +1372,21 @@ ${e instanceof Error ? e.message : String(e)}`,
     await Promise.all(queue);
   }
   return async (tree, file) => {
-    await update(tree, path8.dirname(file.path), file.data);
+    await update(tree, path6.dirname(file.path), file.data);
   };
 }
-var import_unified, import_unist_util_visit2, path8, fs3, import_mdx_plugins, ElementLikeTypes;
+var import_unified, import_unist_util_visit2, path6, fs3, import_mdx_plugins, ElementLikeTypes;
 var init_remark_include = __esm({
   "src/loaders/mdx/remark-include.ts"() {
     "use strict";
     import_unified = require("unified");
     import_unist_util_visit2 = require("unist-util-visit");
-    path8 = __toESM(require("path"), 1);
+    path6 = __toESM(require("path"), 1);
     fs3 = __toESM(require("fs/promises"), 1);
     init_fuma_matter();
     import_mdx_plugins = require("fumadocs-core/mdx-plugins");
     init_remark_unravel();
+    init_mdast_utils();
     ElementLikeTypes = [
       "mdxJsxFlowElement",
       "mdxJsxTextElement",
@@ -1112,48 +1402,66 @@ function remarkPostprocess({
   _format,
   includeProcessedMarkdown = false,
   includeMDAST = false,
+  extractLinkReferences = false,
   valueToExport = []
 }) {
   let _stringifyProcessor;
   const getStringifyProcessor = () => {
-    if (_format === "mdx") return this;
-    return _stringifyProcessor ??= this().use(import_remark_mdx.default).freeze();
+    return _stringifyProcessor ??= _format === "mdx" ? this : (
+      // force Markdown processor to stringify MDX nodes
+      this().use(import_remark_mdx.default).freeze()
+    );
   };
   return (tree, file) => {
-    let title;
-    const urls = [];
-    (0, import_unist_util_visit3.visit)(tree, ["heading", "link"], (node) => {
-      if (node.type === "heading" && node.depth === 1) {
-        title = flattenNode2(node);
-      }
-      if (node.type !== "link") return;
-      urls.push({
-        href: node.url
+    const frontmatter = file.data.frontmatter ??= {};
+    if (!frontmatter.title) {
+      (0, import_unist_util_visit3.visit)(tree, "heading", (node) => {
+        if (node.depth === 1) {
+          frontmatter.title = flattenNode(node);
+          return false;
+        }
+      });
+    }
+    file.data["mdx-export"] ??= [];
+    if (extractLinkReferences) {
+      const urls = [];
+      (0, import_unist_util_visit3.visit)(tree, "link", (node) => {
+        urls.push({
+          href: node.url
+        });
+        return "skip";
+      });
+      file.data["mdx-export"].push({
+        name: "extractedReferences",
+        value: urls
       });
-      return "skip";
-    });
-    if (title) {
-      file.data.frontmatter ??= {};
-      if (!file.data.frontmatter.title) file.data.frontmatter.title = title;
     }
-    file.data.extractedReferences = urls;
     if (includeProcessedMarkdown) {
       const processor = getStringifyProcessor();
-      file.data._markdown = (0, import_mdast_util_to_markdown.toMarkdown)(tree, {
+      const markdown = (0, import_mdast_util_to_markdown.toMarkdown)(tree, {
         ...processor.data("settings"),
         // from https://github.com/remarkjs/remark/blob/main/packages/remark-stringify/lib/index.js
         extensions: processor.data("toMarkdownExtensions") || []
       });
+      file.data["mdx-export"].push({
+        name: "_markdown",
+        value: markdown
+      });
     }
     if (includeMDAST) {
       const options = includeMDAST === true ? {} : includeMDAST;
-      file.data._mdast = JSON.stringify(
+      const mdast = JSON.stringify(
         options.removePosition ? (0, import_unist_util_remove_position.removePosition)(structuredClone(tree)) : tree
       );
+      file.data["mdx-export"].push({
+        name: "_mdast",
+        value: mdast
+      });
     }
-    for (const { name, value } of file.data["mdx-export"] ?? []) {
+    for (const { name, value } of file.data["mdx-export"]) {
       tree.children.unshift(getMdastExport(name, value));
     }
+    file.data["mdx-export"] = [];
     for (const name of valueToExport) {
       if (!(name in file.data)) continue;
       tree.children.unshift(getMdastExport(name, file.data[name]));
@@ -1194,12 +1502,6 @@ function getMdastExport(name, value) {
     }
   };
 }
-function flattenNode2(node) {
-  if ("children" in node)
-    return node.children.map((child) => flattenNode2(child)).join("");
-  if ("value" in node) return node.value;
-  return "";
-}
 var import_unist_util_visit3, import_mdast_util_to_markdown, import_estree_util_value_to_estree, import_unist_util_remove_position, import_remark_mdx;
 var init_remark_postprocess = __esm({
   "src/loaders/mdx/remark-postprocess.ts"() {
@@ -1209,66 +1511,71 @@ var init_remark_postprocess = __esm({
     import_estree_util_value_to_estree = require("estree-util-value-to-estree");
     import_unist_util_remove_position = require("unist-util-remove-position");
     import_remark_mdx = __toESM(require("remark-mdx"), 1);
+    init_mdast_utils();
   }
 });
 
 // src/loaders/mdx/build-mdx.ts
-async function buildMDX(cacheKey, source, options) {
-  const { filePath, frontmatter, data, _compiler, ...rest } = options;
+var build_mdx_exports = {};
+__export(build_mdx_exports, {
+  buildMDX: () => buildMDX
+});
+async function buildMDX(core, collection, {
+  filePath,
+  frontmatter,
+  source,
+  _compiler,
+  environment,
+  isDevelopment
+}) {
+  const mdxOptions = await core.getConfig().getMDXOptions(collection, environment);
   function getProcessor(format) {
-    const key = `${cacheKey}:${format}`;
-    let processor = cache2.get(key);
+    const cache = core.cache;
+    const key = `build-mdx:${collection?.name ?? "global"}:${format}`;
+    let processor = cache.get(key);
     if (!processor) {
+      const postprocessOptions = {
+        _format: format,
+        ...collection?.postprocess,
+        valueToExport: [
+          ...collection?.postprocess?.valueToExport ?? [],
+          "structuredData",
+          "frontmatter"
+        ]
+      };
       processor = (0, import_mdx.createProcessor)({
         outputFormat: "program",
-        ...rest,
+        development: isDevelopment,
+        ...mdxOptions,
         remarkPlugins: [
           remarkInclude,
-          ...rest.remarkPlugins ?? [],
-          [
-            remarkPostprocess,
-            {
-              _format: format,
-              ...options.postprocess,
-              valueToExport: [
-                ...options.postprocess?.valueToExport ?? [],
-                "structuredData",
-                "extractedReferences",
-                "frontmatter",
-                "lastModified",
-                "_markdown",
-                "_mdast"
-              ]
-            }
-          ]
+          ...mdxOptions.remarkPlugins ?? [],
+          [remarkPostprocess, postprocessOptions]
         ],
         format
       });
-      cache2.set(key, processor);
+      cache.set(key, processor);
     }
     return processor;
   }
-  return getProcessor(
-    options.format ?? (filePath.endsWith(".mdx") ? "mdx" : "md")
-  ).process({
+  let vfile = new import_vfile.VFile({
     value: source,
     path: filePath,
-    data: {
-      ...data,
-      frontmatter,
-      _compiler,
-      _getProcessor: getProcessor
-    }
+    data: { frontmatter, _compiler, _getProcessor: getProcessor }
   });
+  if (collection) {
+    vfile = await core.transformVFile({ collection, filePath, source }, vfile);
+  }
+  return getProcessor(filePath.endsWith(".mdx") ? "mdx" : "md").process(vfile);
 }
-var import_mdx, cache2;
+var import_mdx, import_vfile;
 var init_build_mdx = __esm({
   "src/loaders/mdx/build-mdx.ts"() {
     "use strict";
     import_mdx = require("@mdx-js/mdx");
+    import_vfile = require("vfile");
     init_remark_include();
     init_remark_postprocess();
-    cache2 = /* @__PURE__ */ new Map();
   }
 });
 
@@ -1283,20 +1590,20 @@ function createMdxLoader(configLoader) {
       compiler,
       filePath
     }) {
+      const config = await configLoader.getConfig();
       const value = await getSource();
       const matter = fumaMatter(value);
       const parsed = querySchema.parse(query);
-      const config = await configLoader.getConfig();
       let after;
       if (!isDevelopment && config.global.experimentalBuildCache) {
         const cacheDir = config.global.experimentalBuildCache;
         const cacheKey = `${parsed.hash}_${parsed.collection ?? "global"}_${generateCacheHash(filePath)}`;
-        const cached = await import_promises3.default.readFile(import_node_path5.default.join(cacheDir, cacheKey)).then((content) => cacheEntry.parse(JSON.parse(content.toString()))).catch(() => null);
+        const cached = await import_promises3.default.readFile(import_node_path4.default.join(cacheDir, cacheKey)).then((content) => cacheEntry.parse(JSON.parse(content.toString()))).catch(() => null);
         if (cached && cached.hash === generateCacheHash(value)) return cached;
         after = async () => {
           await import_promises3.default.mkdir(cacheDir, { recursive: true });
           await import_promises3.default.writeFile(
-            import_node_path5.default.join(cacheDir, cacheKey),
+            import_node_path4.default.join(cacheDir, cacheKey),
             JSON.stringify({
               ...out,
               hash: generateCacheHash(value)
@@ -1314,15 +1621,10 @@ function createMdxLoader(configLoader) {
           docCollection = collection.docs;
           break;
       }
-      if (docCollection?.schema) {
-        matter.data = await validate(
-          docCollection.schema,
-          matter.data,
-          {
-            source: value,
-            path: filePath
-          },
-          `invalid frontmatter in ${filePath}`
+      if (docCollection) {
+        matter.data = await configLoader.core.transformFrontmatter(
+          { collection: docCollection, filePath, source: value },
+          matter.data
         );
       }
       if (parsed.only === "frontmatter") {
@@ -1331,24 +1633,16 @@ function createMdxLoader(configLoader) {
           map: null
         };
       }
-      const data = {};
-      if (config.global.lastModifiedTime === "git") {
-        data.lastModified = (await getGitTimestamp(filePath))?.getTime();
-      }
       const lineOffset = isDevelopment ? countLines(matter.matter) : 0;
-      const compiled = await buildMDX(
-        `${getConfigHash(config)}:${parsed.collection ?? "global"}`,
-        "\n".repeat(lineOffset) + matter.content,
-        {
-          development: isDevelopment,
-          ...docCollection?.mdxOptions ?? await config.getDefaultMDXOptions(),
-          postprocess: docCollection?.postprocess,
-          data,
-          filePath,
-          frontmatter: matter.data,
-          _compiler: compiler
-        }
-      );
+      const { buildMDX: buildMDX2 } = await Promise.resolve().then(() => (init_build_mdx(), build_mdx_exports));
+      const compiled = await buildMDX2(configLoader.core, docCollection, {
+        isDevelopment,
+        source: "\n".repeat(lineOffset) + matter.content,
+        filePath,
+        frontmatter: matter.data,
+        _compiler: compiler,
+        environment: "bundler"
+      });
       const out = {
         code: String(compiled.value),
         map: compiled.map
@@ -1358,15 +1652,8 @@ function createMdxLoader(configLoader) {
     }
   };
 }
-function getConfigHash(config) {
-  let hash = hashes.get(config);
-  if (hash) return hash;
-  hash = Date.now().toString();
-  hashes.set(config, hash);
-  return hash;
-}
 function generateCacheHash(input) {
-  return (0, import_node_crypto2.createHash)("md5").update(input).digest("hex");
+  return (0, import_node_crypto.createHash)("md5").update(input).digest("hex");
 }
 function countLines(s) {
   let num = 0;
@@ -1375,18 +1662,15 @@ function countLines(s) {
   }
   return num;
 }
-var import_zod, import_promises3, import_node_path5, import_node_crypto2, querySchema, cacheEntry, hashes;
+var import_zod, import_promises3, import_node_path4, import_node_crypto, querySchema, cacheEntry;
 var init_mdx = __esm({
   "src/loaders/mdx/index.ts"() {
     "use strict";
     init_fuma_matter();
-    init_validation();
-    init_git_timestamp();
-    init_build_mdx();
     import_zod = require("zod");
     import_promises3 = __toESM(require("fs/promises"), 1);
-    import_node_path5 = __toESM(require("path"), 1);
-    import_node_crypto2 = require("crypto");
+    import_node_path4 = __toESM(require("path"), 1);
+    import_node_crypto = require("crypto");
     init_loaders();
     querySchema = import_zod.z.object({
       only: import_zod.z.literal(["frontmatter", "all"]).default("all"),
@@ -1397,7 +1681,6 @@ var init_mdx = __esm({
       map: import_zod.z.any().optional(),
       hash: import_zod.z.string().optional()
     });
-    hashes = /* @__PURE__ */ new WeakMap();
   }
 });
 
@@ -1430,7 +1713,7 @@ function toVite(loader) {
     }
   };
 }
-var import_node_url2, import_promises4, import_node_querystring, import_node_path6, import_node_fs;
+var import_node_url2, import_promises4, import_node_querystring, import_node_path5, import_node_fs;
 var init_adapter = __esm({
   "src/loaders/adapter.ts"() {
     "use strict";
@@ -1438,218 +1721,15 @@ var init_adapter = __esm({
     import_promises4 = __toESM(require("fs/promises"), 1);
     import_node_querystring = require("querystring");
     init_validation();
-    import_node_path6 = __toESM(require("path"), 1);
+    import_node_path5 = __toESM(require("path"), 1);
     import_node_fs = require("fs");
   }
 });
 
-// src/utils/glob-import.ts
-function generateGlobImport(patterns, options) {
-  let code = "{";
-  const result = (0, import_tinyglobby.globSync)(patterns, {
-    cwd: options.base
-  });
-  for (const item of result) {
-    const fullPath = import_node_path7.default.join(options.base, item);
-    const url = (0, import_node_url3.pathToFileURL)(fullPath);
-    for (const [k, v] of Object.entries(options.query ?? {})) {
-      url.searchParams.set(k, v);
-    }
-    let line = `${JSON.stringify(item)}: () => import(${JSON.stringify(url.href)})`;
-    if (options.import) {
-      line += `.then(mod => mod[${JSON.stringify(options.import)}])`;
-    }
-    code += `${line}, `;
-  }
-  code += "}";
-  return code;
-}
-var import_tinyglobby, import_node_path7, import_node_url3;
-var init_glob_import = __esm({
-  "src/utils/glob-import.ts"() {
-    "use strict";
-    import_tinyglobby = require("tinyglobby");
-    import_node_path7 = __toESM(require("path"), 1);
-    import_node_url3 = require("url");
-  }
-});
-
-// src/plugins/vite.ts
-function vite({
-  index
-}) {
-  let config;
-  let indexOptions;
-  if (index === false) indexOptions = false;
-  else indexOptions = applyDefaults2(index === true ? {} : index);
-  return {
-    name: "vite",
-    config(v) {
-      config = v;
-    },
-    configureServer(server) {
-      if (!server.watcher || indexOptions === false || indexOptions.runtime === false)
-        return;
-      server.watcher.on("all", (event, file) => {
-        if (event === "change") return;
-        const isUpdated = config.collectionList.some((collection) => {
-          if (collection.type === "docs")
-            return collection.docs.hasFile(file) || collection.meta.hasFile(file);
-          return collection.hasFile(file);
-        });
-        if (isUpdated) {
-          this.core.emitAndWrite({
-            filterPlugin: (plugin) => plugin.name === "vite"
-          });
-        }
-      });
-    },
-    emit() {
-      const out = [];
-      if (indexOptions === false) return out;
-      if (indexOptions.browser) {
-        out.push({
-          path: "browser.ts",
-          content: indexFile2(this, config, indexOptions, "browser")
-        });
-      }
-      out.push({
-        path: "index.ts",
-        content: indexFile2(
-          this,
-          config,
-          indexOptions,
-          indexOptions.browser ? "server" : "all"
-        )
-      });
-      return out;
-    }
-  };
-}
-function applyDefaults2(options) {
-  return {
-    addJsExtension: options.addJsExtension ?? false,
-    browser: options.browser ?? false,
-    runtime: options.runtime ?? false
-  };
-}
-function indexFile2({ configPath, outDir }, config, { addJsExtension, runtime }, environment) {
-  const runtimePath = {
-    all: "fumadocs-mdx/runtime/vite",
-    server: "fumadocs-mdx/runtime/vite.server",
-    browser: "fumadocs-mdx/runtime/vite.browser"
-  }[environment];
-  const lines = [
-    '/// <reference types="vite/client" />',
-    `import { fromConfig } from '${runtimePath}';`,
-    `import type * as Config from '${toImportPath(configPath, {
-      relativeTo: outDir,
-      jsExtension: addJsExtension
-    })}';`,
-    "",
-    `export const create = fromConfig<typeof Config>();`
-  ];
-  function generateCollectionGlob(collection) {
-    if (collection.type === "docs") {
-      const obj = [
-        ident(`doc: ${generateCollectionGlob(collection.docs)}`),
-        ident(`meta: ${generateCollectionGlob(collection.meta)}`)
-      ].join(",\n");
-      return `{
-${obj}
-}`;
-    }
-    const dir = getCollectionDir(collection);
-    if (collection.type === "doc") {
-      const docGlob = generateGlob(collection.patterns, {
-        query: {
-          collection: collection.name
-        },
-        base: dir
-      });
-      if (collection.async) {
-        const headBlob = generateGlob(collection.patterns, {
-          query: {
-            only: "frontmatter",
-            collection: collection.name
-          },
-          import: "frontmatter",
-          base: dir
-        });
-        return `create.docLazy("${collection.name}", "${dir}", ${headBlob}, ${docGlob})`;
-      }
-      return `create.doc("${collection.name}", "${dir}", ${docGlob})`;
-    }
-    return `create.meta("${collection.name}", "${dir}", ${generateGlob(
-      collection.patterns,
-      {
-        import: "default",
-        base: dir,
-        query: {
-          collection: collection.name
-        }
-      }
-    )})`;
-  }
-  function generateGlob(patterns, options) {
-    patterns = patterns.map(normalizeGlobPath);
-    if (runtime === "node" || runtime === "bun") {
-      return generateGlobImport(patterns, options);
-    } else {
-      return `import.meta.glob(${JSON.stringify(patterns)}, ${JSON.stringify(
-        {
-          ...options,
-          base: normalizeGlobPath(import_node_path8.default.relative(outDir, options.base))
-        },
-        null,
-        2
-      )})`;
-    }
-  }
-  for (const collection of config.collectionList) {
-    lines.push("");
-    lines.push(
-      `export const ${collection.name} = ${generateCollectionGlob(collection)};`
-    );
-  }
-  return lines.join("\n");
-}
-function normalizeGlobPath(file) {
-  file = slash(file);
-  if (file.startsWith("./")) return file;
-  if (file.startsWith("/")) return `.${file}`;
-  return `./${file}`;
-}
-function getCollectionDir({ dir }) {
-  if (Array.isArray(dir)) {
-    if (dir.length !== 1)
-      throw new Error(
-        `[Fumadocs MDX] Vite Plugin doesn't support multiple \`dir\` for a collection at the moment.`
-      );
-    return dir[0];
-  }
-  return dir;
-}
-function slash(path13) {
-  const isExtendedLengthPath = path13.startsWith("\\\\?\\");
-  if (isExtendedLengthPath) {
-    return path13;
-  }
-  return path13.replaceAll("\\", "/");
-}
-var import_node_path8;
-var init_vite = __esm({
-  "src/plugins/vite.ts"() {
-    "use strict";
-    init_import_formatter();
-    init_glob_import();
-    import_node_path8 = __toESM(require("path"), 1);
-  }
-});
-
 // src/loaders/config.ts
 function createIntegratedConfigLoader(core) {
   return {
+    core,
     getConfig() {
       return core.getConfig();
     }
@@ -1664,73 +1744,82 @@ var init_config = __esm({
 });
 
 // src/loaders/meta.ts
-function createMetaLoader(configLoader, resolve5 = {}) {
-  const { json: resolveJson = "js", yaml: resolveYaml = "js" } = resolve5;
-  function stringifyOutput(isJson, data) {
-    if (isJson) {
-      return resolveJson === "json" ? JSON.stringify(data) : `export default ${JSON.stringify(data)}`;
-    } else {
-      return resolveYaml === "yaml" ? (0, import_js_yaml3.dump)(data) : `export default ${JSON.stringify(data)}`;
+function createMetaLoader(configLoader, resolve3 = {}) {
+  const { json: resolveJson = "js", yaml: resolveYaml = "js" } = resolve3;
+  function parse2(filePath, source) {
+    try {
+      if (filePath.endsWith(".json")) return JSON.parse(source);
+      if (filePath.endsWith(".yaml")) return (0, import_js_yaml2.load)(source);
+    } catch (e) {
+      throw new Error(`invalid data in ${filePath}`, { cause: e });
     }
+    throw new Error("Unknown file type " + filePath);
   }
-  return {
-    test: metaLoaderGlob,
-    async load({ filePath, query, getSource }) {
-      const parsed = querySchema2.parse(query);
-      const collection = parsed.collection ? (await configLoader.getConfig()).getCollection(parsed.collection) : void 0;
-      if (!collection) return null;
-      const isJson = filePath.endsWith(".json");
-      const source = await getSource();
-      let data;
-      try {
-        data = isJson ? JSON.parse(source) : (0, import_js_yaml3.load)(source);
-      } catch (e) {
-        throw new Error(`invalid data in ${filePath}`, { cause: e });
-      }
-      let schema;
+  function onMeta(source, { filePath, query }) {
+    const parsed = querySchema2.safeParse(query);
+    if (!parsed.success || !parsed.data.collection) return null;
+    const collectionName = parsed.data.collection;
+    return async () => {
+      const config = await configLoader.getConfig();
+      const collection = config.getCollection(collectionName);
+      let metaCollection;
       switch (collection?.type) {
         case "meta":
-          schema = collection.schema;
+          metaCollection = collection;
           break;
         case "docs":
-          schema = collection.meta.schema;
+          metaCollection = collection.meta;
           break;
       }
-      if (schema) {
-        data = await validate(
-          schema,
-          data,
-          { path: filePath, source },
-          `invalid data in ${filePath}`
-        );
+      const data = parse2(filePath, source);
+      if (!metaCollection) return data;
+      return configLoader.core.transformMeta(
+        {
+          collection: metaCollection,
+          filePath,
+          source
+        },
+        data
+      );
+    };
+  }
+  return {
+    test: metaLoaderGlob,
+    async load(input) {
+      const result = onMeta(await input.getSource(), input);
+      if (result === null) return null;
+      const data = await result();
+      if (input.filePath.endsWith(".json")) {
+        return {
+          code: resolveJson === "json" ? JSON.stringify(data) : `export default ${JSON.stringify(data)}`
+        };
+      } else {
+        return {
+          code: resolveYaml === "yaml" ? (0, import_js_yaml2.dump)(data) : `export default ${JSON.stringify(data)}`
+        };
       }
-      return {
-        code: stringifyOutput(isJson, data)
-      };
     },
     bun: {
-      loadSync(source, { filePath }) {
-        const isJson = filePath.endsWith(".json");
-        let data;
-        try {
-          data = isJson ? JSON.parse(source) : (0, import_js_yaml3.load)(source);
-        } catch (e) {
-          throw new Error(`invalid data in ${filePath}`, { cause: e });
-        }
-        return {
+      load(source, input) {
+        const result = onMeta(source, input);
+        if (result === null)
+          return {
+            loader: "object",
+            exports: parse2(input.filePath, source)
+          };
+        return result().then((data) => ({
           loader: "object",
-          exports: data
-        };
+          exports: { default: data }
+        }));
       }
     }
   };
 }
-var import_js_yaml3, import_zod2, querySchema2;
+var import_js_yaml2, import_zod2, querySchema2;
 var init_meta = __esm({
   "src/loaders/meta.ts"() {
     "use strict";
-    import_js_yaml3 = require("js-yaml");
-    init_validation();
+    import_js_yaml2 = require("js-yaml");
     import_zod2 = require("zod");
     init_loaders();
     querySchema2 = import_zod2.z.object({
@@ -1746,8 +1835,9 @@ __export(vite_exports, {
   postInstall: () => postInstall2
 });
 async function mdx(config, pluginOptions = {}) {
-  const options = applyDefaults3(pluginOptions);
-  const core = await createViteCore(options).init({
+  const options = applyDefaults2(pluginOptions);
+  const core = createViteCore(options);
+  await core.init({
     config: buildConfig(config)
   });
   const configLoader = createIntegratedConfigLoader(core);
@@ -1792,26 +1882,27 @@ async function mdx(config, pluginOptions = {}) {
         }
       } catch (e) {
         if (e instanceof ValidationError) {
-          throw new Error(e.toStringFormatted());
+          throw new Error(await e.toStringFormatted());
         }
         throw e;
       }
     }
   };
 }
-async function postInstall2(configPath = findConfigFile(), pluginOptions = {}) {
+async function postInstall2(pluginOptions = {}) {
   const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_load_from_file(), load_from_file_exports));
-  const options = applyDefaults3(pluginOptions);
-  const core = await createViteCore(options).init({
-    config: loadConfig2(configPath, options.outDir, true)
+  const core = createViteCore(applyDefaults2(pluginOptions));
+  await core.init({
+    config: loadConfig2(core, true)
   });
   await core.emitAndWrite();
 }
 function createViteCore({
+  index,
   configPath,
-  outDir,
-  generateIndexFile
+  outDir
 }) {
+  if (index === true) index = {};
   return createCore(
     {
       environment: "vite",
@@ -1819,22 +1910,23 @@ function createViteCore({
       outDir
     },
     [
-      vite({
-        index: generateIndexFile
+      index && indexFile({
+        ...index,
+        target: index.target ?? "vite"
       })
     ]
   );
 }
-function applyDefaults3(options) {
+function applyDefaults2(options) {
   return {
     updateViteConfig: options.updateViteConfig ?? true,
-    generateIndexFile: options.generateIndexFile ?? true,
-    configPath: options.configPath ?? "source.config.ts",
-    outDir: options.outDir ?? ".source"
+    index: options.index ?? true,
+    configPath: options.configPath ?? _Defaults.configPath,
+    outDir: options.outDir ?? _Defaults.outDir
   };
 }
 var import_vite, FumadocsDeps;
-var init_vite2 = __esm({
+var init_vite = __esm({
   "src/vite/index.ts"() {
     "use strict";
     import_vite = require("vite");
@@ -1842,10 +1934,10 @@ var init_vite2 = __esm({
     init_validation();
     init_mdx();
     init_adapter();
-    init_vite();
     init_core();
     init_config();
     init_meta();
+    init_index_file();
     FumadocsDeps = ["fumadocs-core", "fumadocs-ui", "fumadocs-openapi"];
   }
 });
@@ -1853,14 +1945,14 @@ var init_vite2 = __esm({
 // src/bin.ts
 var import_node_fs2 = require("fs");
 async function start() {
-  const [configPath] = process.argv.slice(2);
+  const [configPath, outDir] = process.argv.slice(2);
   const isNext = (0, import_node_fs2.existsSync)("next.config.js") || (0, import_node_fs2.existsSync)("next.config.mjs") || (0, import_node_fs2.existsSync)("next.config.mts") || (0, import_node_fs2.existsSync)("next.config.ts");
   if (isNext) {
-    const { postInstall: postInstall3 } = await Promise.resolve().then(() => (init_next2(), next_exports));
-    await postInstall3(configPath);
+    const { postInstall: postInstall3 } = await Promise.resolve().then(() => (init_next(), next_exports));
+    await postInstall3({ configPath, outDir });
   } else {
-    const { postInstall: postInstall3 } = await Promise.resolve().then(() => (init_vite2(), vite_exports));
-    await postInstall3(configPath);
+    const { postInstall: postInstall3 } = await Promise.resolve().then(() => (init_vite(), vite_exports));
+    await postInstall3({ configPath, outDir });
   }
 }
 void start();