fumadocs-mdx 10.0.2 → 11.0.0

package/dist/{chunk-LRV535YP.mjs → chunk-FXIX4XBC.mjs}

@@ -3,6 +3,7 @@ import { z } from "zod";
 var metaSchema = z.object({
   title: z.string().optional(),
   pages: z.array(z.string()).optional(),
+  description: z.string().optional(),
   root: z.boolean().optional(),
   defaultOpen: z.boolean().optional(),
   icon: z.string().optional()
@@ -20,20 +21,23 @@ var frontmatterSchema = z.object({
 function defineCollections(options) {
   return {
     _doc: "collections",
+    // @ts-expect-error -- internal type inferring
+    _type: void 0,
     ...options
   };
 }
 function defineDocs(options) {
+  const dir = options?.dir ?? "content/docs";
   return {
     docs: defineCollections({
       type: "doc",
-      dir: "content/docs",
+      dir,
       schema: frontmatterSchema,
       ...options?.docs
     }),
     meta: defineCollections({
       type: "meta",
-      dir: "content/docs",
+      dir,
       schema: metaSchema,
       ...options?.meta
     })
@@ -46,14 +50,23 @@ function defineConfig(config = {}) {
 // src/utils/mdx-options.ts
 import {
   rehypeCode,
+  rehypeToc,
   remarkGfm,
   remarkHeading,
   remarkImage,
   remarkStructure
 } from "fumadocs-core/mdx-plugins";
 
-// src/mdx-plugins/utils.ts
+// src/mdx-plugins/remark-exports.ts
 import { valueToEstree } from "estree-util-value-to-estree";
+function remarkMdxExport({ values }) {
+  return (tree, vfile) => {
+    for (const name of values) {
+      if (!(name in vfile.data)) return;
+      tree.children.unshift(getMdastExport(name, vfile.data[name]));
+    }
+  };
+}
 function getMdastExport(name, value) {
   return {
     type: "mdxjsEsm",
@@ -88,16 +101,6 @@ function getMdastExport(name, value) {
   };
 }
 
-// src/mdx-plugins/remark-exports.ts
-function remarkMdxExport({ values }) {
-  return (tree, vfile) => {
-    for (const name of values) {
-      if (!(name in vfile.data)) return;
-      tree.children.unshift(getMdastExport(name, vfile.data[name]));
-    }
-  };
-}
-
 // src/utils/mdx-options.ts
 function pluginOption(def, options = []) {
   const list = def(Array.isArray(options) ? options : []).filter(
@@ -118,7 +121,6 @@ function getDefaultMDXOptions({
 }) {
   const mdxExports = [
     "structuredData",
-    "toc",
     "frontmatter",
     "lastModified",
     ...valueToExport
@@ -126,7 +128,13 @@ function getDefaultMDXOptions({
   const remarkPlugins = pluginOption(
     (v) => [
       remarkGfm,
-      [remarkHeading, remarkHeadingOptions],
+      [
+        remarkHeading,
+        {
+          generateToc: false,
+          ...remarkHeadingOptions
+        }
+      ],
       remarkImageOptions !== false && [remarkImage, remarkImageOptions],
       ...v,
       remarkStructureOptions !== false && [
@@ -140,7 +148,8 @@ function getDefaultMDXOptions({
   const rehypePlugins = pluginOption(
     (v) => [
       rehypeCodeOptions !== false && [rehypeCode, rehypeCodeOptions],
-      ...v
+      ...v,
+      [rehypeToc]
     ],
     mdxOptions.rehypePlugins
   );

package/dist/{chunk-VW6REBOK.mjs → chunk-KD74ZWYJ.mjs}

@@ -20,7 +20,10 @@ function validateConfig(config) {
       continue;
     }
     if (typeof v === "object" && "_doc" in v && v._doc === "collections") {
-      out.collections.set(k, v);
+      out.collections.set(
+        k,
+        v
+      );
       continue;
     }
     if (k === "default") {

package/dist/config/index.d.mts

@@ -1,9 +1,11 @@
+import { F as FileInfo, G as GlobalConfig, M as MarkdownProps, B as BaseCollectionEntry } from '../types-D11VoRzy.mjs';
+export { C as CollectionEntry, D as DefaultMDXOptions, b as GetOutput, I as InferSchema, a as InferSchemaType, g as getDefaultMDXOptions } from '../types-D11VoRzy.mjs';
 import { z, ZodTypeAny } from 'zod';
-import { MDXProps } from 'mdx/types';
-import { StructureOptions, RemarkHeadingOptions, RemarkImageOptions, RehypeCodeOptions, StructuredData } from 'fumadocs-core/mdx-plugins';
-import { TableOfContents } from 'fumadocs-core/server';
 import { ProcessorOptions } from '@mdx-js/mdx';
-import { Pluggable } from 'unified';
+import 'mdx/types';
+import 'fumadocs-core/mdx-plugins';
+import 'fumadocs-core/server';
+import 'unified';
 
 interface MDXOptions extends ProcessorOptions {
     /**
@@ -24,21 +26,24 @@ interface MDXOptions extends ProcessorOptions {
 declare const metaSchema: z.ZodObject<{
     title: z.ZodOptional<z.ZodString>;
     pages: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    description: z.ZodOptional<z.ZodString>;
     root: z.ZodOptional<z.ZodBoolean>;
     defaultOpen: z.ZodOptional<z.ZodBoolean>;
     icon: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
+    root?: boolean | undefined;
     title?: string | undefined;
+    icon?: string | undefined;
     pages?: string[] | undefined;
-    root?: boolean | undefined;
+    description?: string | undefined;
     defaultOpen?: boolean | undefined;
-    icon?: string | undefined;
 }, {
+    root?: boolean | undefined;
     title?: string | undefined;
+    icon?: string | undefined;
     pages?: string[] | undefined;
-    root?: boolean | undefined;
+    description?: string | undefined;
     defaultOpen?: boolean | undefined;
-    icon?: string | undefined;
 }>;
 declare const frontmatterSchema: z.ZodObject<{
     title: z.ZodString;
@@ -68,7 +73,7 @@ interface TransformContext {
      */
     buildMDX: (source: string, options?: ProcessorOptions) => Promise<string>;
 }
-interface Collections<Schema extends ZodTypeAny = ZodTypeAny, Type extends SupportedType = SupportedType, Output extends BaseCollectionEntry = CollectionEntry<Type, z.output<Schema>>> {
+interface BaseCollection<Schema> {
     /**
      * Directories to scan
      */
@@ -80,92 +85,63 @@ interface Collections<Schema extends ZodTypeAny = ZodTypeAny, Type extends Suppo
      */
     files?: string[];
     schema?: Schema | ((ctx: TransformContext) => Schema);
-    /**
-     * content type
-     */
-    type: Type;
+}
+interface MetaCollection<Schema extends ZodTypeAny = ZodTypeAny, TransformOutput = unknown> extends BaseCollection<Schema> {
+    type: 'meta';
     /**
      * Do transformation in runtime.
      *
      * This cannot be optimized by bundlers/loaders, avoid expensive calculations here.
      */
-    transform?: (entry: CollectionEntry<Type, z.output<Schema>>, globalConfig?: GlobalConfig) => Output | Promise<Output>;
-    mdxOptions?: Type extends 'doc' ? MDXOptions : never;
+    transform?: (entry: {
+        data: z.output<Schema>;
+        file: FileInfo;
+    }, globalConfig?: GlobalConfig) => TransformOutput | Promise<TransformOutput>;
 }
-declare function defineCollections<Schema extends ZodTypeAny, Type extends SupportedType, Output extends BaseCollectionEntry = CollectionEntry<Type, z.output<Schema>>>(options: Collections<Schema, Type, Output>): {
-    _doc: 'collections';
-} & Collections<Schema, Type, Output>;
-declare function defineDocs<F extends ZodTypeAny = typeof frontmatterSchema, M extends ZodTypeAny = typeof metaSchema, DocsOut extends BaseCollectionEntry = CollectionEntry<'doc', z.output<F>>, MetaOut extends BaseCollectionEntry = CollectionEntry<'meta', z.output<M>>>(options?: {
-    docs?: Partial<Collections<F, 'doc', DocsOut>>;
-    meta?: Partial<Collections<M, 'meta', MetaOut>>;
-}): {
-    docs: Collections<F, 'doc', DocsOut>;
-    meta: Collections<M, 'meta', MetaOut>;
-};
-declare function defineConfig(config?: GlobalConfig): GlobalConfig;
-
-type ResolvePlugins = Pluggable[] | ((v: Pluggable[]) => Pluggable[]);
-type DefaultMDXOptions = Omit<NonNullable<ProcessorOptions>, 'rehypePlugins' | 'remarkPlugins' | '_ctx'> & {
-    rehypePlugins?: ResolvePlugins;
-    remarkPlugins?: ResolvePlugins;
-    /**
-     * Properties to export from `vfile.data`
-     */
-    valueToExport?: string[];
-    remarkStructureOptions?: StructureOptions | false;
-    remarkHeadingOptions?: RemarkHeadingOptions;
-    remarkImageOptions?: RemarkImageOptions | false;
-    rehypeCodeOptions?: RehypeCodeOptions | false;
-};
-declare function getDefaultMDXOptions({ valueToExport, rehypeCodeOptions, remarkImageOptions, remarkHeadingOptions, remarkStructureOptions, ...mdxOptions }: DefaultMDXOptions): ProcessorOptions;
-
-interface GlobalConfig {
-    /**
-     * Configure global MDX options
-     */
-    mdxOptions?: DefaultMDXOptions;
+interface DocCollection<Schema extends ZodTypeAny = ZodTypeAny, Async extends boolean = boolean, TransformOutput = unknown> extends BaseCollection<Schema> {
+    type: 'doc';
     /**
-     * Fetch last modified time with specified version control
-     * @defaultValue 'none'
+     * Do transformation in runtime.
+     *
+     * This cannot be optimized by bundlers/loaders, avoid expensive calculations here.
      */
-    lastModifiedTime?: 'git' | 'none';
+    transform?: (entry: {
+        data: z.output<Schema>;
+        file: FileInfo;
+        mdx: Async extends true ? MarkdownProps : never;
+    }, globalConfig?: GlobalConfig) => TransformOutput | Promise<TransformOutput>;
+    mdxOptions?: MDXOptions;
     /**
-     * Generate manifest file on build mode
-     *
-     * @defaultValue false
+     * Load files with async
      */
-    generateManifest?: boolean;
-}
-type InferSchema<C> = C extends Collections<infer Schema, any, any> ? Schema : never;
-type InferSchemaType<C> = z.output<InferSchema<C>>;
-type InferCollectionsProps<C> = SupportedTypes[C extends Collections<any, infer Type, any> ? Type : never];
-interface FileInfo {
-    path: string;
-    absolutePath: string;
+    async?: Async;
 }
-interface MarkdownProps {
-    body: (props: MDXProps) => React.ReactElement;
-    structuredData: StructuredData;
-    toc: TableOfContents;
-    _exports: Record<string, unknown>;
+declare function defineCollections<T extends 'doc' | 'meta', Schema extends ZodTypeAny = ZodTypeAny, Async extends boolean = false, TransformOutput = unknown>(options: {
+    type: T;
+} & (T extends 'doc' ? DocCollection<Schema, Async, TransformOutput> : MetaCollection<Schema, TransformOutput>)): {
+    _doc: 'collections';
+    type: T;
+    _type: {
+        async: Async;
+        transform: TransformOutput;
+        runtime: T extends 'doc' ? Async extends true ? z.infer<Schema> & BaseCollectionEntry & {
+            load: () => Promise<MarkdownProps>;
+        } : Omit<MarkdownProps, keyof z.infer<Schema>> & z.infer<Schema> & BaseCollectionEntry : typeof options extends MetaCollection ? z.infer<Schema> & BaseCollectionEntry : never;
+    };
+};
+declare function defineDocs<DocData extends ZodTypeAny = typeof frontmatterSchema, MetaData extends ZodTypeAny = typeof metaSchema, DocAsync extends boolean = false, DocOut = unknown, MetaOut = unknown>(options?: {
     /**
-     * Only available when `lastModifiedTime` is enabled on MDX loader
+     * The directory to scan files
+     *
+     *  @defaultValue '/content/docs'
      */
-    lastModified?: Date;
-}
-interface SupportedTypes {
-    meta: {};
-    doc: MarkdownProps;
-}
-type SupportedType = keyof SupportedTypes;
-type CollectionEntry<Type extends SupportedType, Output> = Omit<SupportedTypes[Type], keyof Output> & Output & BaseCollectionEntry;
-interface BaseCollectionEntry {
-    _file: FileInfo;
-}
-type EntryFromCollection<C> = C extends Collections<any, any, infer Output> ? Output : never;
-/**
- * Get output type of collections
- */
-type GetOutput<C> = EntryFromCollection<C>[];
+    dir?: string | string[];
+    docs?: Partial<DocCollection<DocData, DocAsync, DocOut>>;
+    meta?: Partial<MetaCollection<MetaData, MetaOut>>;
+}): {
+    docs: ReturnType<typeof defineCollections<'doc', DocData, DocAsync, DocOut>>;
+    meta: ReturnType<typeof defineCollections<'meta', MetaData, false, MetaOut>>;
+};
+declare function defineConfig(config?: GlobalConfig): GlobalConfig;
 
-export { type BaseCollectionEntry, type CollectionEntry, type Collections, type DefaultMDXOptions, type EntryFromCollection, type FileInfo, type GetOutput, type GlobalConfig, type InferCollectionsProps, type InferSchema, type InferSchemaType, type SupportedType, type SupportedTypes, type TransformContext, defineCollections, defineConfig, defineDocs, frontmatterSchema, getDefaultMDXOptions, metaSchema };
+export { type BaseCollection, BaseCollectionEntry, type DocCollection, FileInfo, GlobalConfig, MarkdownProps, type MetaCollection, type TransformContext, defineCollections, defineConfig, defineDocs, frontmatterSchema, metaSchema };

package/dist/config/index.mjs

@@ -5,7 +5,7 @@ import {
   frontmatterSchema,
   getDefaultMDXOptions,
   metaSchema
-} from "../chunk-LRV535YP.mjs";
+} from "../chunk-FXIX4XBC.mjs";
 export {
   defineCollections,
   defineConfig,

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 import { PageData, MetaData, Source } from 'fumadocs-core/source';
-import { SupportedType, FileInfo, EntryFromCollection, Collections, CollectionEntry } from './config/index.mjs';
+import { F as FileInfo, B as BaseCollectionEntry } from './types-D11VoRzy.mjs';
 import { MetaFile } from './loader-mdx.mjs';
 import 'zod';
 import 'mdx/types';
@@ -9,8 +9,9 @@ import '@mdx-js/mdx';
 import 'unified';
 import 'webpack';
 
-declare function toRuntime(type: SupportedType, file: Record<string, unknown>, info: FileInfo): EntryFromCollection<Collections>;
-declare function createMDXSource<Doc extends CollectionEntry<'doc', PageData>, Meta extends CollectionEntry<'meta', MetaData>>(docs: Doc[], meta: Meta[]): Source<{
+declare function toRuntime(type: 'doc' | 'meta', file: Record<string, unknown>, info: FileInfo): unknown;
+declare function toRuntimeAsync(frontmatter: Record<string, unknown>, load: () => Promise<Record<string, unknown>>, info: FileInfo): unknown;
+declare function createMDXSource<Doc extends PageData & BaseCollectionEntry, Meta extends MetaData & BaseCollectionEntry>(docs: Doc[], meta: Meta[]): Source<{
     pageData: Doc;
     metaData: Meta;
 }>;
@@ -21,4 +22,4 @@ interface Manifest {
     })[];
 }
 
-export { type Manifest, createMDXSource, toRuntime };
+export { type Manifest, createMDXSource, toRuntime, toRuntimeAsync };

package/dist/index.mjs

@@ -1,7 +1,4 @@
 // src/runtime/resolve-files.ts
-import path from "node:path";
-var pageTypes = [".md", ".mdx"];
-var metaTypes = [".json", ".yaml"];
 function resolveFiles({
   docs,
   meta,
@@ -10,38 +7,23 @@ function resolveFiles({
   const outputs = [];
   for (const entry of docs) {
     if (!entry._file.path.startsWith(rootDir)) continue;
-    const ext = path.extname(entry._file.path);
-    if (pageTypes.includes(ext)) {
-      outputs.push({
-        type: "page",
-        path: entry._file.path,
-        data: entry
-      });
-      continue;
-    }
-    console.warn(
-      `Unknown Type: ${ext} on ${entry._file.path}, expected: ${pageTypes.toString()}`
-    );
+    outputs.push({
+      type: "page",
+      path: entry._file.path,
+      data: entry
+    });
   }
   for (const entry of meta) {
-    if (!entry._file.path.startsWith(rootDir)) continue;
-    const ext = path.extname(entry._file.path);
-    if (metaTypes.includes(ext)) {
-      outputs.push({
-        type: "meta",
-        path: entry._file.path,
-        data: entry
-      });
-      continue;
-    }
-    console.warn(
-      `Unknown Type: ${ext} on ${entry._file.path}, expected: ${metaTypes.toString()}`
-    );
+    outputs.push({
+      type: "meta",
+      path: entry._file.path,
+      data: entry
+    });
   }
   return outputs;
 }
 
-// src/runtime/create.ts
+// src/runtime/index.ts
 function toRuntime(type, file, info) {
   if (type === "doc") {
     const { default: body, frontmatter, ...exports } = file;
@@ -58,6 +40,19 @@ function toRuntime(type, file, info) {
     _file: info
   };
 }
+function toRuntimeAsync(frontmatter, load, info) {
+  return {
+    async load() {
+      const { default: body, ...res } = await load();
+      return {
+        body,
+        ...res
+      };
+    },
+    ...frontmatter,
+    _file: info
+  };
+}
 function createMDXSource(docs, meta) {
   return {
     files: (rootDir) => resolveFiles({
@@ -69,5 +64,6 @@ function createMDXSource(docs, meta) {
 }
 export {
   createMDXSource,
-  toRuntime
+  toRuntime,
+  toRuntimeAsync
 };

package/dist/loader-mdx.mjs

@@ -1,39 +1,18 @@
+import {
+  getDefaultMDXOptions
+} from "./chunk-FXIX4XBC.mjs";
 import {
   getConfigHash,
   getManifestEntryPath,
   loadConfigCached
-} from "./chunk-VW6REBOK.mjs";
-import {
-  getDefaultMDXOptions
-} from "./chunk-LRV535YP.mjs";
+} from "./chunk-KD74ZWYJ.mjs";
 
 // src/loader-mdx.ts
-import path3 from "node:path";
+import path2 from "node:path";
 import fs2 from "node:fs/promises";
 import { parse } from "node:querystring";
 import grayMatter from "gray-matter";
 
-// src/utils/find-collection.ts
-import path from "node:path";
-import micromatch from "micromatch";
-function findCollectionId(config, file, type) {
-  const cached = config._runtime.files.get(file);
-  if (cached) return cached;
-  for (const [name, collection] of config.collections.entries()) {
-    if (collection.type !== type) continue;
-    const dirs = Array.isArray(collection.dir) ? collection.dir : [collection.dir];
-    const isInDir = dirs.some((dir) => {
-      const relative = path.relative(dir, path.dirname(file));
-      return !relative.startsWith("..") && !path.isAbsolute(relative);
-    });
-    if (!isInDir) continue;
-    const isIncluded = collection.files ? micromatch.isMatch(file, collection.files) : true;
-    if (!isIncluded) continue;
-    config._runtime.files.set(file, name);
-    return name;
-  }
-}
-
 // src/utils/build-mdx.ts
 import { createProcessor } from "@mdx-js/mdx";
 var cache = /* @__PURE__ */ new Map();
@@ -90,7 +69,7 @@ function formatError(file, error) {
 }
 
 // src/utils/git-timestamp.ts
-import path2 from "node:path";
+import path from "node:path";
 import fs from "node:fs";
 import { spawn } from "cross-spawn";
 var cache2 = /* @__PURE__ */ new Map();
@@ -98,12 +77,12 @@ function getGitTimestamp(file) {
   const cachedTimestamp = cache2.get(file);
   if (cachedTimestamp) return Promise.resolve(cachedTimestamp);
   return new Promise((resolve, reject) => {
-    const cwd = path2.dirname(file);
+    const cwd = path.dirname(file);
     if (!fs.existsSync(cwd)) {
       resolve(void 0);
       return;
     }
-    const fileName = path2.basename(file);
+    const fileName = path.basename(file);
     const child = spawn("git", ["log", "-1", '--pretty="%ai"', fileName], {
       cwd
     });
@@ -136,8 +115,11 @@ async function loader(source, callback) {
   const query = getQuery(this.resourceQuery);
   const configHash = query.hash ?? await getConfigHash(_ctx.configPath);
   const config = await loadConfigCached(_ctx.configPath, configHash);
-  const collectionId = query.collection ?? findCollectionId(config, filePath, "doc");
-  const collection = collectionId !== void 0 ? config.collections.get(collectionId) : void 0;
+  const collectionId = query.collection;
+  let collection = collectionId !== void 0 ? config.collections.get(collectionId) : void 0;
+  if (collection && collection.type !== "doc") {
+    collection = void 0;
+  }
   const mdxOptions = collection?.mdxOptions ?? getDefaultMDXOptions(config.global?.mdxOptions ?? {});
   function getTransformContext() {
     return {
@@ -166,7 +148,7 @@ async function loader(source, callback) {
   }
   const props = matter.data._mdx ?? {};
   if (props.mirror) {
-    const mirrorPath = path3.resolve(path3.dirname(filePath), props.mirror);
+    const mirrorPath = path2.resolve(path2.dirname(filePath), props.mirror);
     this.addDependency(mirrorPath);
     matter.content = await fs2.readFile(mirrorPath).then((res) => grayMatter(res.toString()).content);
   }
@@ -201,7 +183,7 @@ async function loader(source, callback) {
     }
   } catch (error) {
     if (!(error instanceof Error)) throw error;
-    const fpath = path3.relative(context, filePath);
+    const fpath = path2.relative(context, filePath);
     error.message = `${fpath}:${error.name}: ${error.message}`;
     callback(error);
   }

package/dist/next/index.d.mts

@@ -1,13 +1,21 @@
 import { NextConfig } from 'next';
 
+/**
+ * Start a MDX server that builds index and manifest files.
+ *
+ * In development mode, it starts a file watcher to auto-update output as your input changes.
+ */
+declare function start(dev: boolean, configPath: string, outDir: string): Promise<void>;
+
 interface CreateMDXOptions {
     /**
      * Path to source configuration file
      */
     configPath?: string;
 }
+
 declare function createMDX({ configPath, }?: CreateMDXOptions): (nextConfig?: NextConfig) => NextConfig;
 
 declare function postInstall(configPath?: string): Promise<void>;
 
-export { type CreateMDXOptions, createMDX, postInstall };
+export { type CreateMDXOptions, createMDX, postInstall, start };

package/dist/next/index.mjs

@@ -5,7 +5,7 @@ import {
   loadConfig,
   loadConfigCached,
   writeManifest
-} from "../chunk-VW6REBOK.mjs";
+} from "../chunk-KD74ZWYJ.mjs";
 
 // src/next/create.ts
 import path3 from "node:path";
@@ -13,82 +13,90 @@ import path3 from "node:path";
 // src/map/index.ts
 import path2 from "node:path";
 import fs from "node:fs";
-
-// src/map/watcher.ts
-import { watch } from "chokidar";
-function watcher(configPath, config) {
-  const deps = [configPath];
-  for (const collection of config.collections.values()) {
-    if (Array.isArray(collection.dir)) deps.push(...collection.dir);
-    else deps.push(collection.dir);
-  }
-  return watch(deps, {
-    ignoreInitial: true
-  });
-}
+import { readFile, writeFile } from "node:fs/promises";
+import grayMatter from "gray-matter";
 
 // src/map/generate.ts
-import path from "node:path";
+import * as path from "node:path";
 import fg from "fast-glob";
-async function generateJS(configPath, config, outputPath, hash) {
+async function generateJS(configPath, config, outputPath, hash, getFrontmatter) {
   const outDir2 = path.dirname(outputPath);
-  const imports = ['import { toRuntime } from "fumadocs-mdx"'];
+  const imports = [
+    {
+      type: "named",
+      names: ["toRuntime", "toRuntimeAsync"],
+      specifier: "fumadocs-mdx"
+    }
+  ];
   const importedCollections = /* @__PURE__ */ new Set();
-  const sources = [];
-  let importId = 0;
   config._runtime.files.clear();
-  await Promise.all(
-    Array.from(config.collections.entries()).map(async ([name, collection]) => {
-      const entries = [];
-      const dirs = Array.isArray(collection.dir) ? collection.dir : [collection.dir];
-      await Promise.all(
-        dirs.map(async (dir) => {
-          const included = await fg(collection.files ?? ["**/*"], {
-            cwd: dir,
-            absolute: true
-          });
-          for (const file of included) {
-            if (getTypeFromPath(file) !== collection.type) continue;
-            if (config._runtime.files.has(file)) {
-              console.warn(
-                `[MDX] Files cannot exist in multiple collections: ${file} (${config._runtime.files.get(file) ?? ""})`
-              );
-              continue;
-            }
-            config._runtime.files.set(file, name);
-            const importName = `file_${(importId++).toString()}`;
-            imports.push(
-              `import * as ${importName} from ${JSON.stringify(`${toImportPath(file, outDir2)}?collection=${name}&hash=${hash}`)}`
-            );
-            const info = {
-              path: path.relative(dir, file),
-              absolutePath: file
-            };
-            entries.push(
-              `toRuntime("${collection.type}", ${importName}, ${JSON.stringify(info)})`
-            );
-          }
-        })
-      );
-      if (collection.transform) {
-        if (config.global) importedCollections.add("default");
-        importedCollections.add(name);
-        sources.push(
-          `export const ${name} = await Promise.all([${entries.join(",")}].map(v => c_${name}.transform(v, c_default)))`
-        );
-      } else {
-        sources.push(`export const ${name} = [${entries.join(",")}]`);
+  const entries = Array.from(config.collections.entries());
+  const declares = entries.map(async ([k, collection]) => {
+    const files = await getCollectionFiles(collection);
+    const items = files.map(async (file, i) => {
+      config._runtime.files.set(file.absolutePath, k);
+      if (collection.type === "doc" && collection.async) {
+        const importPath = `${toImportPath(file.absolutePath, outDir2)}?hash=${hash}&collection=${k}`;
+        const frontmatter = await getFrontmatter(file.absolutePath);
+        return `toRuntimeAsync(${JSON.stringify(frontmatter)}, () => import(${JSON.stringify(importPath)}), ${JSON.stringify(file)})`;
       }
+      const importName = `${k}_${i.toString()}`;
+      imports.push({
+        type: "namespace",
+        name: importName,
+        specifier: `${toImportPath(file.absolutePath, outDir2)}?collection=${k}&hash=${hash}`
+      });
+      return `toRuntime("${collection.type}", ${importName}, ${JSON.stringify(file)})`;
+    });
+    const resolvedItems = await Promise.all(items);
+    if (collection.transform) {
+      if (config.global) importedCollections.add("default");
+      importedCollections.add(k);
+    }
+    return collection.transform ? `export const ${k} = await Promise.all([${resolvedItems.join(", ")}].map(v => c_${k}.transform(v, ${config.global ? "c_default" : "undefined"})));` : `export const ${k} = [${resolvedItems.join(", ")}];`;
+  });
+  const resolvedDeclares = await Promise.all(declares);
+  if (importedCollections.size > 0) {
+    imports.push({
+      type: "named",
+      names: Array.from(importedCollections.values()).sort().map((v) => [v, `c_${v}`]),
+      specifier: toImportPath(configPath, outDir2)
+    });
+  }
+  return [...imports.map(getImportCode), ...resolvedDeclares].join("\n");
+}
+async function getCollectionFiles(collection) {
+  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 fg(collection.files ?? "**/*", {
+        cwd: dir,
+        absolute: true
+      });
+      result.forEach((item) => {
+        if (getTypeFromPath(item) !== collection.type) return;
+        files.set(item, {
+          path: path.relative(dir, item),
+          absolutePath: item
+        });
+      });
     })
   );
-  if (importedCollections.size > 0) {
-    imports.push(
-      `import { ${Array.from(importedCollections.values()).map((v) => `${v} as c_${v}`).join(
-        ", "
-      )} } from ${JSON.stringify(toImportPath(configPath, outDir2))}`
+  return Array.from(files.values());
+}
+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 [...imports, ...sources].join("\n");
+  return `import ${specifier}`;
 }
 function toImportPath(file, dir) {
   let importPath = path.relative(dir, file);
@@ -119,10 +127,28 @@ async function start(dev, configPath, outDir2) {
   const manifestPath = path2.resolve(outDir2, "manifest.json");
   const jsOut = path2.resolve(outDir2, `index.js`);
   const typeOut = path2.resolve(outDir2, `index.d.ts`);
+  const frontmatterCache = /* @__PURE__ */ new Map();
+  let hookUpdate = false;
+  const readFrontmatter = async (file) => {
+    const cached = frontmatterCache.get(file);
+    if (cached) return cached;
+    hookUpdate = true;
+    return grayMatter({
+      content: await readFile(file).then((res) => res.toString())
+    }).data;
+  };
+  fs.mkdirSync(outDir2, { recursive: true });
+  fs.writeFileSync(
+    jsOut,
+    await generateJS(configPath, config, jsOut, configHash, readFrontmatter)
+  );
+  fs.writeFileSync(typeOut, generateTypes(configPath, config, typeOut));
+  console.log("[MDX] initialized map file");
   if (dev) {
+    const { watcher } = await import("../watcher-DL2NRJWG.mjs");
     const instance = watcher(configPath, config);
     instance.on("ready", () => {
-      console.log("[MDX] started dev server");
+      if (!instance._readyEmitted) console.log("[MDX] started dev server");
     });
     instance.on("all", (event, file) => {
       const onUpdate = async () => {
@@ -130,13 +156,20 @@ async function start(dev, configPath, outDir2) {
         if (isConfigFile) {
           configHash = await getConfigHash(configPath);
           config = await loadConfigCached(configPath, configHash);
-          fs.writeFileSync(typeOut, generateTypes(configPath, config, typeOut));
+          await writeFile(typeOut, generateTypes(configPath, config, typeOut));
           console.log("[MDX] Updated map types");
         }
-        if (isConfigFile || event !== "change") {
-          fs.writeFileSync(
+        if (isConfigFile || event !== "change" || hookUpdate) {
+          if (event === "change") frontmatterCache.delete(file);
+          await writeFile(
             jsOut,
-            await generateJS(configPath, config, jsOut, configHash)
+            await generateJS(
+              configPath,
+              config,
+              jsOut,
+              configHash,
+              readFrontmatter
+            )
           );
           console.log("[MDX] Updated map file");
         }
@@ -148,13 +181,6 @@ async function start(dev, configPath, outDir2) {
       void instance.close();
     });
   }
-  fs.mkdirSync(outDir2, { recursive: true });
-  fs.writeFileSync(
-    jsOut,
-    await generateJS(configPath, config, jsOut, configHash)
-  );
-  fs.writeFileSync(typeOut, generateTypes(configPath, config, typeOut));
-  console.log("[MDX] initialized map file");
   if (config.global?.generateManifest && !dev) {
     process.on("exit", () => {
       console.log("[MDX] writing manifest");
@@ -171,7 +197,8 @@ function createMDX({
 } = {}) {
   const isDev = process.argv.includes("dev");
   const isBuild = process.argv.includes("build");
-  if (isDev || isBuild) {
+  if ((isDev || isBuild) && process.env._FUMADOCS_MDX !== "1") {
+    process.env._FUMADOCS_MDX = "1";
     void start(isDev, configPath, outDir);
   }
   return (nextConfig = {}) => {
@@ -235,5 +262,6 @@ async function postInstall(configPath = findConfigFile()) {
 }
 export {
   createMDX,
-  postInstall
+  postInstall,
+  start
 };

package/dist/types-D11VoRzy.d.mts

@@ -0,0 +1,77 @@
+import { AnyZodObject, z } from 'zod';
+import { MDXProps } from 'mdx/types';
+import { StructureOptions, RemarkHeadingOptions, RemarkImageOptions, RehypeCodeOptions, StructuredData } from 'fumadocs-core/mdx-plugins';
+import { TableOfContents } from 'fumadocs-core/server';
+import { ProcessorOptions } from '@mdx-js/mdx';
+import { Pluggable } from 'unified';
+
+type ResolvePlugins = Pluggable[] | ((v: Pluggable[]) => Pluggable[]);
+type DefaultMDXOptions = Omit<NonNullable<ProcessorOptions>, 'rehypePlugins' | 'remarkPlugins' | '_ctx'> & {
+    rehypePlugins?: ResolvePlugins;
+    remarkPlugins?: ResolvePlugins;
+    /**
+     * Properties to export from `vfile.data`
+     */
+    valueToExport?: string[];
+    remarkStructureOptions?: StructureOptions | false;
+    remarkHeadingOptions?: RemarkHeadingOptions;
+    remarkImageOptions?: RemarkImageOptions | false;
+    rehypeCodeOptions?: RehypeCodeOptions | false;
+};
+declare function getDefaultMDXOptions({ valueToExport, rehypeCodeOptions, remarkImageOptions, remarkHeadingOptions, remarkStructureOptions, ...mdxOptions }: DefaultMDXOptions): ProcessorOptions;
+
+interface GlobalConfig {
+    /**
+     * Configure global MDX options
+     */
+    mdxOptions?: DefaultMDXOptions;
+    /**
+     * Fetch last modified time with specified version control
+     * @defaultValue 'none'
+     */
+    lastModifiedTime?: 'git' | 'none';
+    /**
+     * Generate manifest file on build mode
+     *
+     * @defaultValue false
+     */
+    generateManifest?: boolean;
+}
+type InferSchema<CollectionOut> = CollectionOut extends {
+    _type: {
+        schema: infer T;
+    };
+} ? T : never;
+type InferSchemaType<C> = InferSchema<C> extends AnyZodObject ? z.output<InferSchema<C>> : never;
+interface FileInfo {
+    path: string;
+    absolutePath: string;
+}
+interface MarkdownProps {
+    body: (props: MDXProps) => React.ReactElement;
+    structuredData: StructuredData;
+    toc: TableOfContents;
+    _exports: Record<string, unknown>;
+    /**
+     * Only available when `lastModifiedTime` is enabled on MDX loader
+     */
+    lastModified?: Date;
+}
+type CollectionEntry<CollectionOut extends {
+    _type: {
+        runtime: unknown;
+    };
+}> = CollectionOut['_type']['runtime'];
+interface BaseCollectionEntry {
+    _file: FileInfo;
+}
+/**
+ * Get output type of collections
+ */
+type GetOutput<C extends {
+    _type: {
+        runtime: unknown;
+    };
+}> = CollectionEntry<C>[];
+
+export { type BaseCollectionEntry as B, type CollectionEntry as C, type DefaultMDXOptions as D, type FileInfo as F, type GlobalConfig as G, type InferSchema as I, type MarkdownProps as M, type InferSchemaType as a, type GetOutput as b, getDefaultMDXOptions as g };

package/dist/watcher-DL2NRJWG.mjs

@@ -0,0 +1,16 @@
+// src/map/watcher.ts
+import { watch } from "chokidar";
+function watcher(configPath, config) {
+  const deps = [configPath];
+  for (const collection of config.collections.values()) {
+    if (Array.isArray(collection.dir)) deps.push(...collection.dir);
+    else deps.push(collection.dir);
+  }
+  return watch(deps, {
+    ignoreInitial: true,
+    persistent: true
+  });
+}
+export {
+  watcher
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fumadocs-mdx",
-  "version": "10.0.2",
+  "version": "11.0.0",
   "description": "The built-in source for Fumadocs",
   "keywords": [
     "NextJs",
@@ -27,16 +27,6 @@
   },
   "main": "./dist/index.mjs",
   "types": "./dist/index.mts",
-  "typesVersions": {
-    "*": {
-      "config": [
-        "./dist/config/index.d.mts"
-      ],
-      "next": [
-        "./dist/next/index.d.mts"
-      ]
-    }
-  },
   "bin": "./bin.mjs",
   "files": [
     "dist/*",
@@ -44,10 +34,10 @@
     "bin.mjs"
   ],
   "dependencies": {
-    "@mdx-js/mdx": "^3.0.1",
-    "chokidar": "^3.6.0",
+    "@mdx-js/mdx": "^3.1.0",
+    "chokidar": "^4.0.1",
     "cross-spawn": "^7.0.3",
-    "esbuild": "^0.23.1",
+    "esbuild": "^0.24.0",
     "estree-util-value-to-estree": "^3.1.2",
     "fast-glob": "^3.3.1",
     "gray-matter": "^4.0.3",
@@ -59,17 +49,18 @@
     "@types/mdast": "^4.0.3",
     "@types/mdx": "^2.0.13",
     "@types/micromatch": "^4.0.9",
-    "@types/react": "^18.3.5",
-    "next": "^14.2.8",
+    "@types/react": "^18.3.11",
+    "next": "15.0.0",
     "unified": "^11.0.5",
-    "webpack": "^5.90.3",
+    "vfile": "^6.0.3",
+    "webpack": "^5.95.0",
     "eslint-config-custom": "0.0.0",
-    "fumadocs-core": "13.4.8",
+    "fumadocs-core": "14.0.1",
     "tsconfig": "0.0.0"
   },
   "peerDependencies": {
-    "fumadocs-core": "^13.2.1",
-    "next": ">= 14.1.0"
+    "fumadocs-core": "^14.0.0",
+    "next": "14.x.x || 15.x.x"
   },
   "publishConfig": {
     "access": "public"