fumadocs-mdx 11.5.8 → 11.6.1

package/dist/{chunk-KGLACICA.js → chunk-2ZOW45YZ.js}

@@ -1,5 +1,6 @@
 // src/utils/schema.ts
 import { z } from "zod";
+import picocolors from "picocolors";
 var metaSchema = z.object({
   title: z.string().optional(),
   pages: z.array(z.string()).optional(),
@@ -16,6 +17,28 @@ var frontmatterSchema = z.object({
   // Fumadocs OpenAPI generated
   _openapi: z.object({}).passthrough().optional()
 });
+var ValidationError = class extends Error {
+  constructor(message, issues) {
+    super(message);
+    this.issues = issues;
+  }
+  print() {
+    console.error(
+      [
+        `[MDX] ${this.message}:`,
+        ...this.issues.map(
+          (issue) => picocolors.redBright(
+            `- ${picocolors.bold(issue.path?.join(".") ?? "*")}: ${issue.message}`
+          )
+        )
+      ].join("\n")
+    );
+  }
+  toString() {
+    return `${this.message}:
+${this.issues.map((issue) => `  ${issue.path}: ${issue.message}`).join("\n")}`;
+  }
+};
 async function validate(schema, data, context, errorMessage) {
   if (typeof schema === "function" && !("~standard" in schema)) {
     schema = schema(context);
@@ -25,19 +48,16 @@ async function validate(schema, data, context, errorMessage) {
       data
     );
     if (result.issues) {
-      throw new Error(formatError(errorMessage, result.issues));
+      throw new ValidationError(errorMessage, result.issues);
     }
     return result.value;
   }
   return data;
 }
-function formatError(message, issues) {
-  return `${message}:
-${issues.map((issue) => `  ${issue.path}: ${issue.message}`).join("\n")}`;
-}
 
 export {
   metaSchema,
   frontmatterSchema,
+  ValidationError,
   validate
 };

package/dist/config/index.cjs

@@ -42,6 +42,7 @@ module.exports = __toCommonJS(config_exports);
 
 // src/utils/schema.ts
 var import_zod = require("zod");
+var import_picocolors = __toESM(require("picocolors"), 1);
 var metaSchema = import_zod.z.object({
   title: import_zod.z.string().optional(),
   pages: import_zod.z.array(import_zod.z.string()).optional(),

package/dist/config/index.js

@@ -1,7 +1,7 @@
 import {
   frontmatterSchema,
   metaSchema
-} from "../chunk-KGLACICA.js";
+} from "../chunk-2ZOW45YZ.js";
 import {
   remarkInclude
 } from "../chunk-MK7EXW7O.js";

package/dist/index.d.cts

@@ -1,7 +1,6 @@
 import { PageData, MetaData, Source, VirtualFile } from 'fumadocs-core/source';
 import { B as BaseCollectionEntry } from './define-CGHfrlrJ.cjs';
-import { R as Runtime } from './types-DCyuz-WB.cjs';
-export { a as RuntimeFile } from './types-DCyuz-WB.cjs';
+import { R as Runtime } from './types-CTLLuPxW.cjs';
 import '@mdx-js/mdx';
 import 'mdx/types';
 import 'fumadocs-core/mdx-plugins';

package/dist/index.d.ts

@@ -1,7 +1,6 @@
 import { PageData, MetaData, Source, VirtualFile } from 'fumadocs-core/source';
 import { B as BaseCollectionEntry } from './define-CGHfrlrJ.js';
-import { R as Runtime } from './types-DfVJrYH1.js';
-export { a as RuntimeFile } from './types-DfVJrYH1.js';
+import { R as Runtime } from './types-CUbprvBB.js';
 import '@mdx-js/mdx';
 import 'mdx/types';
 import 'fumadocs-core/mdx-plugins';

package/dist/loader-mdx.cjs

@@ -389,6 +389,7 @@ function getGitTimestamp(file) {
 
 // src/utils/schema.ts
 var import_zod = require("zod");
+var import_picocolors = __toESM(require("picocolors"), 1);
 var metaSchema = import_zod.z.object({
   title: import_zod.z.string().optional(),
   pages: import_zod.z.array(import_zod.z.string()).optional(),
@@ -405,6 +406,28 @@ var frontmatterSchema = import_zod.z.object({
   // Fumadocs OpenAPI generated
   _openapi: import_zod.z.object({}).passthrough().optional()
 });
+var ValidationError = class extends Error {
+  constructor(message, issues) {
+    super(message);
+    this.issues = issues;
+  }
+  print() {
+    console.error(
+      [
+        `[MDX] ${this.message}:`,
+        ...this.issues.map(
+          (issue) => import_picocolors.default.redBright(
+            `- ${import_picocolors.default.bold(issue.path?.join(".") ?? "*")}: ${issue.message}`
+          )
+        )
+      ].join("\n")
+    );
+  }
+  toString() {
+    return `${this.message}:
+${this.issues.map((issue) => `  ${issue.path}: ${issue.message}`).join("\n")}`;
+  }
+};
 async function validate(schema, data, context, errorMessage) {
   if (typeof schema === "function" && !("~standard" in schema)) {
     schema = schema(context);
@@ -414,16 +437,12 @@ async function validate(schema, data, context, errorMessage) {
       data
     );
     if (result.issues) {
-      throw new Error(formatError(errorMessage, result.issues));
+      throw new ValidationError(errorMessage, result.issues);
     }
     return result.value;
   }
   return data;
 }
-function formatError(message, issues) {
-  return `${message}:
-${issues.map((issue) => `  ${issue.path}: ${issue.message}`).join("\n")}`;
-}
 
 // src/loader-mdx.ts
 function parseQuery(query) {
@@ -467,7 +486,7 @@ async function loader(source, callback) {
         source,
         path: filePath
       },
-      `invalid frontmatter in ${filePath}:`
+      `invalid frontmatter in ${filePath}`
     );
   }
   let timestamp;

package/dist/loader-mdx.js

@@ -4,7 +4,7 @@ import {
 } from "./chunk-HFLDWPJA.js";
 import {
   validate
-} from "./chunk-KGLACICA.js";
+} from "./chunk-2ZOW45YZ.js";
 import {
   remarkInclude
 } from "./chunk-MK7EXW7O.js";
@@ -118,7 +118,7 @@ async function loader(source, callback) {
         source,
         path: filePath
       },
-      `invalid frontmatter in ${filePath}:`
+      `invalid frontmatter in ${filePath}`
     );
   }
   let timestamp;

package/dist/next/index.cjs

@@ -35,7 +35,7 @@ var watcher_exports = {};
 __export(watcher_exports, {
   watcher: () => watcher
 });
-function watcher(configPath, config) {
+function watcher(configPath, config, ignored) {
   const deps = [configPath];
   function add(dir) {
     if (Array.isArray(dir)) deps.push(...dir);
@@ -51,6 +51,7 @@ function watcher(configPath, config) {
   }
   return (0, import_chokidar.watch)(deps, {
     ignoreInitial: true,
+    ignored,
     persistent: true
   });
 }
@@ -167,11 +168,11 @@ async function getConfigHash(configPath) {
 
 // src/map/index.ts
 var path3 = __toESM(require("path"), 1);
-var fs4 = __toESM(require("fs/promises"), 1);
+var fs3 = __toESM(require("fs/promises"), 1);
 
 // src/map/generate.ts
 var path2 = __toESM(require("path"), 1);
-var fs3 = __toESM(require("fs/promises"), 1);
+var fs2 = __toESM(require("fs/promises"), 1);
 var import_fast_glob = __toESM(require("fast-glob"), 1);
 
 // src/utils/get-type-from-path.ts
@@ -186,6 +187,7 @@ function getTypeFromPath(path6) {
 
 // src/utils/schema.ts
 var import_zod = require("zod");
+var import_picocolors = __toESM(require("picocolors"), 1);
 var metaSchema = import_zod.z.object({
   title: import_zod.z.string().optional(),
   pages: import_zod.z.array(import_zod.z.string()).optional(),
@@ -202,6 +204,28 @@ var frontmatterSchema = import_zod.z.object({
   // Fumadocs OpenAPI generated
   _openapi: import_zod.z.object({}).passthrough().optional()
 });
+var ValidationError = class extends Error {
+  constructor(message, issues) {
+    super(message);
+    this.issues = issues;
+  }
+  print() {
+    console.error(
+      [
+        `[MDX] ${this.message}:`,
+        ...this.issues.map(
+          (issue) => import_picocolors.default.redBright(
+            `- ${import_picocolors.default.bold(issue.path?.join(".") ?? "*")}: ${issue.message}`
+          )
+        )
+      ].join("\n")
+    );
+  }
+  toString() {
+    return `${this.message}:
+${this.issues.map((issue) => `  ${issue.path}: ${issue.message}`).join("\n")}`;
+  }
+};
 async function validate(schema, data, context, errorMessage) {
   if (typeof schema === "function" && !("~standard" in schema)) {
     schema = schema(context);
@@ -211,16 +235,12 @@ async function validate(schema, data, context, errorMessage) {
       data
     );
     if (result.issues) {
-      throw new Error(formatError(errorMessage, result.issues));
+      throw new ValidationError(errorMessage, result.issues);
     }
     return result.value;
   }
   return data;
 }
-function formatError(message, issues) {
-  return `${message}:
-${issues.map((issue) => `  ${issue.path}: ${issue.message}`).join("\n")}`;
-}
 
 // src/map/file-cache.ts
 var import_lru_cache = require("lru-cache");
@@ -242,46 +262,12 @@ var fileCache = {
   }
 };
 
-// src/utils/read-frontmatter.ts
-var fs2 = __toESM(require("fs"), 1);
-var import_gray_matter = __toESM(require("gray-matter"), 1);
-async function readFrontmatter(file) {
-  const readStream = fs2.createReadStream(file, {
-    highWaterMark: 250
-  });
-  return new Promise((res, rej) => {
-    let idx = 0;
-    let str = "";
-    readStream.on("data", (_chunk) => {
-      const chunk = _chunk.toString();
-      if (idx === 0 && !chunk.startsWith("---")) {
-        res({});
-        readStream.close();
-        return;
-      }
-      str += chunk;
-      idx++;
-      if (str.includes("\n---")) {
-        res(
-          (0, import_gray_matter.default)({
-            content: str
-          }).data
-        );
-        readStream.close();
-      }
-    });
-    readStream.on("end", () => res({}));
-    readStream.on("error", (e) => rej(e));
-  });
-}
-
 // src/map/generate.ts
-async function readFrontmatterWithCache(file) {
-  const cached = fileCache.read("read-frontmatter", file);
+var import_gray_matter = __toESM(require("gray-matter"), 1);
+async function readFileWithCache(file) {
+  const cached = fileCache.read("read-file", file);
   if (cached) return cached;
-  const res = await readFrontmatter(file);
-  fileCache.write("read-frontmatter", file, res);
-  return res;
+  return (await fs2.readFile(file)).toString();
 }
 async function generateJS(configPath, config, outputPath, configHash) {
   const outDir2 = path2.dirname(outputPath);
@@ -299,28 +285,8 @@ async function generateJS(configPath, config, outputPath, configHash) {
     })
   ];
   const entries = Array.from(config.collections.entries());
-  async function getEntries(collectionName, collection, files) {
+  async function getDocEntries(collectionName, files) {
     const items = files.map(async (file, i) => {
-      if (collection.type === "meta") {
-        const cached = fileCache.read("generate-js", file.absolutePath);
-        if (cached) return cached;
-        const source = (await fs3.readFile(file.absolutePath)).toString();
-        let data = JSON.parse(source);
-        if (collection?.schema) {
-          data = await validate(
-            collection.schema,
-            data,
-            {
-              source,
-              path: file.absolutePath
-            },
-            `invalid data in ${file.absolutePath}:`
-          );
-        }
-        const entry = `{ info: ${JSON.stringify(file)}, data: ${JSON.stringify(data)} }`;
-        fileCache.write("generate-js", file.absolutePath, entry);
-        return entry;
-      }
       const importId = `${collectionName}_${i}`;
       lines.unshift(
         getImportCode({
@@ -333,7 +299,29 @@ async function generateJS(configPath, config, outputPath, configHash) {
     });
     return Promise.all(items);
   }
-  async function getAsyncEntries(files) {
+  async function getMetaEntries(collection, files) {
+    const items = files.map(async (file) => {
+      const source = await readFileWithCache(file.absolutePath).catch(() => "");
+      let data = source.length === 0 ? {} : JSON.parse(source);
+      if (collection?.schema) {
+        data = await validate(
+          collection.schema,
+          data,
+          {
+            source,
+            path: file.absolutePath
+          },
+          `invalid data in ${file.absolutePath}`
+        );
+      }
+      return JSON.stringify({
+        info: file,
+        data
+      });
+    });
+    return Promise.all(items);
+  }
+  async function getAsyncEntries(collection, files) {
     if (!asyncInit) {
       lines.unshift(
         getImportCode({
@@ -347,9 +335,21 @@ async function generateJS(configPath, config, outputPath, configHash) {
       asyncInit = true;
     }
     const entries2 = files.map(async (file) => {
+      const parsed = (0, import_gray_matter.default)(
+        await readFileWithCache(file.absolutePath).catch(() => "")
+      );
+      if (collection.schema) {
+        parsed.data = await validate(
+          collection.schema,
+          parsed.data,
+          { path: file.absolutePath, source: parsed.content },
+          `invalid frontmatter in ${file.absolutePath}`
+        );
+      }
       return JSON.stringify({
         info: file,
-        data: await readFrontmatterWithCache(file.absolutePath)
+        data: parsed.data,
+        content: parsed.content
       });
     });
     return Promise.all(entries2);
@@ -358,23 +358,23 @@ async function generateJS(configPath, config, outputPath, configHash) {
     if (collection.type === "docs") {
       const docs = await getCollectionFiles(collection.docs);
       const metas = await getCollectionFiles(collection.meta);
-      const metaEntries = (await getEntries(k, collection.meta, metas)).join(
+      const metaEntries = (await getMetaEntries(collection.meta, metas)).join(
         ", "
       );
       if (collection.docs.async) {
-        const docsEntries2 = (await getAsyncEntries(docs)).join(", ");
+        const docsEntries2 = (await getAsyncEntries(collection.docs, docs)).join(
+          ", "
+        );
         return `export const ${k} = _runtimeAsync.docs<typeof _source.${k}>([${docsEntries2}], [${metaEntries}], "${k}", _sourceConfig)`;
       }
-      const docsEntries = (await getEntries(k, collection.docs, docs)).join(
-        ", "
-      );
+      const docsEntries = (await getDocEntries(k, docs)).join(", ");
       return `export const ${k} = _runtime.docs<typeof _source.${k}>([${docsEntries}], [${metaEntries}])`;
     }
     const files = await getCollectionFiles(collection);
     if (collection.type === "doc" && collection.async) {
-      return `export const ${k} = _runtimeAsync.doc<typeof _source.${k}>([${(await getAsyncEntries(files)).join(", ")}], "${k}", _sourceConfig)`;
+      return `export const ${k} = _runtimeAsync.doc<typeof _source.${k}>([${(await getAsyncEntries(collection, files)).join(", ")}], "${k}", _sourceConfig)`;
     }
-    return `export const ${k} = _runtime.${collection.type}<typeof _source.${k}>([${(await getEntries(k, collection, files)).join(", ")}]);`;
+    return `export const ${k} = _runtime.${collection.type}<typeof _source.${k}>([${(await getDocEntries(k, files)).join(", ")}]);`;
   });
   const resolvedDeclares = await Promise.all(declares);
   return [
@@ -430,24 +430,29 @@ function toImportPath(file, dir) {
 
 // src/map/index.ts
 async function start(dev, configPath, outDir2) {
-  void fs4.rm(path3.resolve(outDir2, `index.js`), { force: true });
-  void fs4.rm(path3.resolve(outDir2, `index.d.ts`), { force: true });
-  await fs4.mkdir(outDir2, { recursive: true });
   let configHash = await getConfigHash(configPath);
   let config = await loadConfig(configPath, configHash, true);
   const outPath = path3.resolve(outDir2, `index.ts`);
   async function updateMapFile() {
-    console.time(`[MDX] update map file`);
-    await fs4.writeFile(
-      outPath,
-      await generateJS(configPath, config, outPath, configHash)
-    );
-    console.timeEnd(`[MDX] update map file`);
+    const start2 = Date.now();
+    try {
+      await fs3.writeFile(
+        outPath,
+        await generateJS(configPath, config, outPath, configHash)
+      );
+    } catch (err) {
+      if (err instanceof ValidationError) {
+        err.print();
+      } else {
+        console.error(err);
+      }
+    }
+    console.log(`[MDX] updated map file in ${Date.now() - start2}ms`);
   }
   await updateMapFile();
   if (dev) {
     const { watcher: watcher2 } = await Promise.resolve().then(() => (init_watcher(), watcher_exports));
-    const instance = watcher2(configPath, config);
+    const instance = watcher2(configPath, config, [outPath]);
     instance.on("ready", () => {
       console.log("[MDX] started dev server");
     });
@@ -492,22 +497,19 @@ function createMDX({
     };
     return {
       ...nextConfig,
-      experimental: {
-        ...nextConfig.experimental,
-        turbo: {
-          ...nextConfig.experimental?.turbo,
-          rules: {
-            ...nextConfig.experimental?.turbo?.rules,
-            // @ts-expect-error -- safe types
-            "*.{md,mdx}": {
-              loaders: [
-                {
-                  loader: "fumadocs-mdx/loader-mdx",
-                  options: mdxLoaderOptions
-                }
-              ],
-              as: "*.js"
-            }
+      turbopack: {
+        ...nextConfig?.turbopack,
+        rules: {
+          ...nextConfig?.turbopack?.rules,
+          // @ts-expect-error -- safe
+          "*.{md,mdx}": {
+            loaders: [
+              {
+                loader: "fumadocs-mdx/loader-mdx",
+                options: mdxLoaderOptions
+              }
+            ],
+            as: "*.js"
           }
         }
       },
@@ -535,21 +537,14 @@ function createMDX({
 
 // src/postinstall.ts
 var path5 = __toESM(require("path"), 1);
-var fs5 = __toESM(require("fs"), 1);
+var fs4 = __toESM(require("fs/promises"), 1);
 async function postInstall(configPath = findConfigFile()) {
   const jsOut = path5.resolve(".source/index.ts");
   const hash = await getConfigHash(configPath);
   const config = await loadConfig(configPath, hash, true);
-  fs5.mkdirSync(path5.dirname(jsOut), { recursive: true });
-  fs5.writeFileSync(
-    jsOut,
-    await generateJS(
-      configPath,
-      config,
-      path5.resolve(".source/index.ts"),
-      hash
-    )
-  );
+  await fs4.rm(path5.dirname(jsOut), { recursive: true });
+  await fs4.mkdir(path5.dirname(jsOut), { recursive: true });
+  await fs4.writeFile(jsOut, await generateJS(configPath, config, jsOut, hash));
   console.log("[MDX] types generated");
 }
 // Annotate the CommonJS export names for ESM import in node:

package/dist/next/index.js

@@ -4,8 +4,9 @@ import {
   loadConfig
 } from "../chunk-HFLDWPJA.js";
 import {
+  ValidationError,
   validate
-} from "../chunk-KGLACICA.js";
+} from "../chunk-2ZOW45YZ.js";
 import "../chunk-DRVUBK5B.js";
 
 // src/next/create.ts
@@ -13,11 +14,11 @@ import path3 from "node:path";
 
 // src/map/index.ts
 import * as path2 from "node:path";
-import * as fs3 from "node:fs/promises";
+import * as fs2 from "node:fs/promises";
 
 // src/map/generate.ts
 import * as path from "node:path";
-import * as fs2 from "node:fs/promises";
+import * as fs from "node:fs/promises";
 import fg from "fast-glob";
 
 // src/utils/get-type-from-path.ts
@@ -50,46 +51,12 @@ var fileCache = {
   }
 };
 
-// src/utils/read-frontmatter.ts
-import * as fs from "node:fs";
-import grayMatter from "gray-matter";
-async function readFrontmatter(file) {
-  const readStream = fs.createReadStream(file, {
-    highWaterMark: 250
-  });
-  return new Promise((res, rej) => {
-    let idx = 0;
-    let str = "";
-    readStream.on("data", (_chunk) => {
-      const chunk = _chunk.toString();
-      if (idx === 0 && !chunk.startsWith("---")) {
-        res({});
-        readStream.close();
-        return;
-      }
-      str += chunk;
-      idx++;
-      if (str.includes("\n---")) {
-        res(
-          grayMatter({
-            content: str
-          }).data
-        );
-        readStream.close();
-      }
-    });
-    readStream.on("end", () => res({}));
-    readStream.on("error", (e) => rej(e));
-  });
-}
-
 // src/map/generate.ts
-async function readFrontmatterWithCache(file) {
-  const cached = fileCache.read("read-frontmatter", file);
+import matter from "gray-matter";
+async function readFileWithCache(file) {
+  const cached = fileCache.read("read-file", file);
   if (cached) return cached;
-  const res = await readFrontmatter(file);
-  fileCache.write("read-frontmatter", file, res);
-  return res;
+  return (await fs.readFile(file)).toString();
 }
 async function generateJS(configPath, config, outputPath, configHash) {
   const outDir2 = path.dirname(outputPath);
@@ -107,28 +74,8 @@ async function generateJS(configPath, config, outputPath, configHash) {
     })
   ];
   const entries = Array.from(config.collections.entries());
-  async function getEntries(collectionName, collection, files) {
+  async function getDocEntries(collectionName, files) {
     const items = files.map(async (file, i) => {
-      if (collection.type === "meta") {
-        const cached = fileCache.read("generate-js", file.absolutePath);
-        if (cached) return cached;
-        const source = (await fs2.readFile(file.absolutePath)).toString();
-        let data = JSON.parse(source);
-        if (collection?.schema) {
-          data = await validate(
-            collection.schema,
-            data,
-            {
-              source,
-              path: file.absolutePath
-            },
-            `invalid data in ${file.absolutePath}:`
-          );
-        }
-        const entry = `{ info: ${JSON.stringify(file)}, data: ${JSON.stringify(data)} }`;
-        fileCache.write("generate-js", file.absolutePath, entry);
-        return entry;
-      }
       const importId = `${collectionName}_${i}`;
       lines.unshift(
         getImportCode({
@@ -141,7 +88,29 @@ async function generateJS(configPath, config, outputPath, configHash) {
     });
     return Promise.all(items);
   }
-  async function getAsyncEntries(files) {
+  async function getMetaEntries(collection, files) {
+    const items = files.map(async (file) => {
+      const source = await readFileWithCache(file.absolutePath).catch(() => "");
+      let data = source.length === 0 ? {} : JSON.parse(source);
+      if (collection?.schema) {
+        data = await validate(
+          collection.schema,
+          data,
+          {
+            source,
+            path: file.absolutePath
+          },
+          `invalid data in ${file.absolutePath}`
+        );
+      }
+      return JSON.stringify({
+        info: file,
+        data
+      });
+    });
+    return Promise.all(items);
+  }
+  async function getAsyncEntries(collection, files) {
     if (!asyncInit) {
       lines.unshift(
         getImportCode({
@@ -155,9 +124,21 @@ async function generateJS(configPath, config, outputPath, configHash) {
       asyncInit = true;
     }
     const entries2 = files.map(async (file) => {
+      const parsed = matter(
+        await readFileWithCache(file.absolutePath).catch(() => "")
+      );
+      if (collection.schema) {
+        parsed.data = await validate(
+          collection.schema,
+          parsed.data,
+          { path: file.absolutePath, source: parsed.content },
+          `invalid frontmatter in ${file.absolutePath}`
+        );
+      }
       return JSON.stringify({
         info: file,
-        data: await readFrontmatterWithCache(file.absolutePath)
+        data: parsed.data,
+        content: parsed.content
       });
     });
     return Promise.all(entries2);
@@ -166,23 +147,23 @@ async function generateJS(configPath, config, outputPath, configHash) {
     if (collection.type === "docs") {
       const docs = await getCollectionFiles(collection.docs);
       const metas = await getCollectionFiles(collection.meta);
-      const metaEntries = (await getEntries(k, collection.meta, metas)).join(
+      const metaEntries = (await getMetaEntries(collection.meta, metas)).join(
         ", "
       );
       if (collection.docs.async) {
-        const docsEntries2 = (await getAsyncEntries(docs)).join(", ");
+        const docsEntries2 = (await getAsyncEntries(collection.docs, docs)).join(
+          ", "
+        );
         return `export const ${k} = _runtimeAsync.docs<typeof _source.${k}>([${docsEntries2}], [${metaEntries}], "${k}", _sourceConfig)`;
       }
-      const docsEntries = (await getEntries(k, collection.docs, docs)).join(
-        ", "
-      );
+      const docsEntries = (await getDocEntries(k, docs)).join(", ");
       return `export const ${k} = _runtime.docs<typeof _source.${k}>([${docsEntries}], [${metaEntries}])`;
     }
     const files = await getCollectionFiles(collection);
     if (collection.type === "doc" && collection.async) {
-      return `export const ${k} = _runtimeAsync.doc<typeof _source.${k}>([${(await getAsyncEntries(files)).join(", ")}], "${k}", _sourceConfig)`;
+      return `export const ${k} = _runtimeAsync.doc<typeof _source.${k}>([${(await getAsyncEntries(collection, files)).join(", ")}], "${k}", _sourceConfig)`;
     }
-    return `export const ${k} = _runtime.${collection.type}<typeof _source.${k}>([${(await getEntries(k, collection, files)).join(", ")}]);`;
+    return `export const ${k} = _runtime.${collection.type}<typeof _source.${k}>([${(await getDocEntries(k, files)).join(", ")}]);`;
   });
   const resolvedDeclares = await Promise.all(declares);
   return [
@@ -238,24 +219,29 @@ function toImportPath(file, dir) {
 
 // src/map/index.ts
 async function start(dev, configPath, outDir2) {
-  void fs3.rm(path2.resolve(outDir2, `index.js`), { force: true });
-  void fs3.rm(path2.resolve(outDir2, `index.d.ts`), { force: true });
-  await fs3.mkdir(outDir2, { recursive: true });
   let configHash = await getConfigHash(configPath);
   let config = await loadConfig(configPath, configHash, true);
   const outPath = path2.resolve(outDir2, `index.ts`);
   async function updateMapFile() {
-    console.time(`[MDX] update map file`);
-    await fs3.writeFile(
-      outPath,
-      await generateJS(configPath, config, outPath, configHash)
-    );
-    console.timeEnd(`[MDX] update map file`);
+    const start2 = Date.now();
+    try {
+      await fs2.writeFile(
+        outPath,
+        await generateJS(configPath, config, outPath, configHash)
+      );
+    } catch (err) {
+      if (err instanceof ValidationError) {
+        err.print();
+      } else {
+        console.error(err);
+      }
+    }
+    console.log(`[MDX] updated map file in ${Date.now() - start2}ms`);
   }
   await updateMapFile();
   if (dev) {
-    const { watcher } = await import("../watcher-IAZDSTU7.js");
-    const instance = watcher(configPath, config);
+    const { watcher } = await import("../watcher-7O2HAQ63.js");
+    const instance = watcher(configPath, config, [outPath]);
     instance.on("ready", () => {
       console.log("[MDX] started dev server");
     });
@@ -300,22 +286,19 @@ function createMDX({
     };
     return {
       ...nextConfig,
-      experimental: {
-        ...nextConfig.experimental,
-        turbo: {
-          ...nextConfig.experimental?.turbo,
-          rules: {
-            ...nextConfig.experimental?.turbo?.rules,
-            // @ts-expect-error -- safe types
-            "*.{md,mdx}": {
-              loaders: [
-                {
-                  loader: "fumadocs-mdx/loader-mdx",
-                  options: mdxLoaderOptions
-                }
-              ],
-              as: "*.js"
-            }
+      turbopack: {
+        ...nextConfig?.turbopack,
+        rules: {
+          ...nextConfig?.turbopack?.rules,
+          // @ts-expect-error -- safe
+          "*.{md,mdx}": {
+            loaders: [
+              {
+                loader: "fumadocs-mdx/loader-mdx",
+                options: mdxLoaderOptions
+              }
+            ],
+            as: "*.js"
           }
         }
       },
@@ -343,21 +326,14 @@ function createMDX({
 
 // src/postinstall.ts
 import * as path4 from "node:path";
-import * as fs4 from "node:fs";
+import * as fs3 from "node:fs/promises";
 async function postInstall(configPath = findConfigFile()) {
   const jsOut = path4.resolve(".source/index.ts");
   const hash = await getConfigHash(configPath);
   const config = await loadConfig(configPath, hash, true);
-  fs4.mkdirSync(path4.dirname(jsOut), { recursive: true });
-  fs4.writeFileSync(
-    jsOut,
-    await generateJS(
-      configPath,
-      config,
-      path4.resolve(".source/index.ts"),
-      hash
-    )
-  );
+  await fs3.rm(path4.dirname(jsOut), { recursive: true });
+  await fs3.mkdir(path4.dirname(jsOut), { recursive: true });
+  await fs3.writeFile(jsOut, await generateJS(configPath, config, jsOut, hash));
   console.log("[MDX] types generated");
 }
 export {

package/dist/runtime/async.cjs

@@ -35,7 +35,6 @@ __export(async_exports, {
 });
 module.exports = __toCommonJS(async_exports);
 var import_mdx_remote = require("@fumadocs/mdx-remote");
-var fs2 = __toESM(require("fs/promises"), 1);
 
 // src/mdx-plugins/remark-include.ts
 var import_unist_util_visit = require("unist-util-visit");
@@ -230,14 +229,15 @@ async function initCompiler(config, collection) {
 var _runtimeAsync = {
   doc(files, collection, config) {
     const init = initCompiler(config, collection);
-    return files.map(({ info: file, data: frontmatter }) => {
+    return files.map(({ info: file, data, content }) => {
       return {
-        ...frontmatter,
+        ...data,
         _file: file,
+        content,
         async load() {
           const compiler = await init;
           const out = await compiler.compile({
-            source: (await fs2.readFile(file.absolutePath)).toString(),
+            source: content,
             filePath: file.absolutePath
           });
           return {

package/dist/runtime/async.d.cts

@@ -1,4 +1,4 @@
-import { L as LoadedConfig, b as RuntimeAsync } from '../types-DCyuz-WB.cjs';
+import { L as LoadedConfig, a as RuntimeAsync } from '../types-CTLLuPxW.cjs';
 import '../define-CGHfrlrJ.cjs';
 import '@mdx-js/mdx';
 import 'mdx/types';

package/dist/runtime/async.d.ts

@@ -1,4 +1,4 @@
-import { L as LoadedConfig, b as RuntimeAsync } from '../types-DfVJrYH1.js';
+import { L as LoadedConfig, a as RuntimeAsync } from '../types-CUbprvBB.js';
 import '../define-CGHfrlrJ.js';
 import '@mdx-js/mdx';
 import 'mdx/types';

package/dist/runtime/async.js

@@ -11,7 +11,6 @@ import {
 
 // src/runtime/async.ts
 import { createCompiler } from "@fumadocs/mdx-remote";
-import * as fs from "node:fs/promises";
 import {
   remarkStructure
 } from "fumadocs-core/mdx-plugins";
@@ -35,14 +34,15 @@ async function initCompiler(config, collection) {
 var _runtimeAsync = {
   doc(files, collection, config) {
     const init = initCompiler(config, collection);
-    return files.map(({ info: file, data: frontmatter }) => {
+    return files.map(({ info: file, data, content }) => {
       return {
-        ...frontmatter,
+        ...data,
         _file: file,
+        content,
         async load() {
           const compiler = await init;
           const out = await compiler.compile({
-            source: (await fs.readFile(file.absolutePath)).toString(),
+            source: content,
             filePath: file.absolutePath
           });
           return {

package/dist/{types-DCyuz-WB.d.cts → types-CTLLuPxW.d.cts}

@@ -19,6 +19,11 @@ interface RuntimeFile {
     info: FileInfo;
     data: Record<string, unknown>;
 }
+interface AsyncRuntimeFile {
+    info: FileInfo;
+    data: Record<string, unknown>;
+    content: string;
+}
 type DocOut<Schema extends StandardSchemaV1> = Omit<MarkdownProps, keyof StandardSchemaV1.InferOutput<Schema>> & StandardSchemaV1.InferOutput<Schema> & BaseCollectionEntry;
 type MetaOut<Schema extends StandardSchemaV1> = StandardSchemaV1.InferOutput<Schema> & BaseCollectionEntry;
 interface Runtime {
@@ -58,16 +63,17 @@ interface Runtime {
     } : never;
 }
 type AsyncDocOut<Schema extends StandardSchemaV1> = StandardSchemaV1.InferOutput<Schema> & BaseCollectionEntry & {
+    content: string;
     load: () => Promise<MarkdownProps>;
 };
 interface RuntimeAsync {
-    doc: <C>(files: RuntimeFile[], collection: string, config: LoadedConfig) => C extends {
+    doc: <C>(files: AsyncRuntimeFile[], collection: string, config: LoadedConfig) => C extends {
         type: 'doc';
         _type: {
             schema: infer Schema extends StandardSchemaV1;
         };
     } ? AsyncDocOut<Schema>[] : never;
-    docs: <C>(docs: RuntimeFile[], metas: RuntimeFile[], collection: string, config: LoadedConfig) => C extends {
+    docs: <C>(docs: AsyncRuntimeFile[], metas: RuntimeFile[], collection: string, config: LoadedConfig) => C extends {
         type: 'docs';
         docs: {
             type: 'doc';
@@ -91,4 +97,4 @@ interface RuntimeAsync {
     } : never;
 }
 
-export type { LoadedConfig as L, Runtime as R, RuntimeFile as a, RuntimeAsync as b };
+export type { LoadedConfig as L, Runtime as R, RuntimeAsync as a };

package/dist/{types-DfVJrYH1.d.ts → types-CUbprvBB.d.ts}

@@ -19,6 +19,11 @@ interface RuntimeFile {
     info: FileInfo;
     data: Record<string, unknown>;
 }
+interface AsyncRuntimeFile {
+    info: FileInfo;
+    data: Record<string, unknown>;
+    content: string;
+}
 type DocOut<Schema extends StandardSchemaV1> = Omit<MarkdownProps, keyof StandardSchemaV1.InferOutput<Schema>> & StandardSchemaV1.InferOutput<Schema> & BaseCollectionEntry;
 type MetaOut<Schema extends StandardSchemaV1> = StandardSchemaV1.InferOutput<Schema> & BaseCollectionEntry;
 interface Runtime {
@@ -58,16 +63,17 @@ interface Runtime {
     } : never;
 }
 type AsyncDocOut<Schema extends StandardSchemaV1> = StandardSchemaV1.InferOutput<Schema> & BaseCollectionEntry & {
+    content: string;
     load: () => Promise<MarkdownProps>;
 };
 interface RuntimeAsync {
-    doc: <C>(files: RuntimeFile[], collection: string, config: LoadedConfig) => C extends {
+    doc: <C>(files: AsyncRuntimeFile[], collection: string, config: LoadedConfig) => C extends {
         type: 'doc';
         _type: {
             schema: infer Schema extends StandardSchemaV1;
         };
     } ? AsyncDocOut<Schema>[] : never;
-    docs: <C>(docs: RuntimeFile[], metas: RuntimeFile[], collection: string, config: LoadedConfig) => C extends {
+    docs: <C>(docs: AsyncRuntimeFile[], metas: RuntimeFile[], collection: string, config: LoadedConfig) => C extends {
         type: 'docs';
         docs: {
             type: 'doc';
@@ -91,4 +97,4 @@ interface RuntimeAsync {
     } : never;
 }
 
-export type { LoadedConfig as L, Runtime as R, RuntimeFile as a, RuntimeAsync as b };
+export type { LoadedConfig as L, Runtime as R, RuntimeAsync as a };

package/dist/{watcher-IAZDSTU7.js → watcher-7O2HAQ63.js}

@@ -1,6 +1,6 @@
 // src/map/watcher.ts
 import { watch } from "chokidar";
-function watcher(configPath, config) {
+function watcher(configPath, config, ignored) {
   const deps = [configPath];
   function add(dir) {
     if (Array.isArray(dir)) deps.push(...dir);
@@ -16,6 +16,7 @@ function watcher(configPath, config) {
   }
   return watch(deps, {
     ignoreInitial: true,
+    ignored,
     persistent: true
   });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fumadocs-mdx",
-  "version": "11.5.8",
+  "version": "11.6.1",
   "description": "The built-in source for Fumadocs",
   "keywords": [
     "NextJs",
@@ -47,32 +47,33 @@
     "chokidar": "^4.0.3",
     "cross-spawn": "^7.0.6",
     "esbuild": "^0.25.2",
-    "estree-util-value-to-estree": "^3.3.2",
+    "estree-util-value-to-estree": "^3.3.3",
     "fast-glob": "^3.3.3",
     "gray-matter": "^4.0.3",
     "lru-cache": "^11.1.0",
+    "picocolors": "^1.1.1",
     "unist-util-visit": "^5.0.0",
-    "zod": "^3.24.2"
+    "zod": "^3.24.3"
   },
   "devDependencies": {
     "@types/cross-spawn": "^6.0.6",
     "@types/mdast": "^4.0.3",
     "@types/mdx": "^2.0.13",
-    "@types/react": "^19.1.0",
+    "@types/react": "^19.1.2",
     "mdast-util-mdx-jsx": "^3.2.0",
-    "next": "^15.2.4",
+    "next": "^15.3.1",
     "unified": "^11.0.5",
     "vfile": "^6.0.3",
-    "webpack": "^5.97.1",
+    "webpack": "^5.99.5",
     "@fumadocs/mdx-remote": "1.3.0",
     "eslint-config-custom": "0.0.0",
-    "fumadocs-core": "15.2.4",
+    "fumadocs-core": "15.2.9",
     "tsconfig": "0.0.0"
   },
   "peerDependencies": {
     "@fumadocs/mdx-remote": "^1.2.0",
     "fumadocs-core": "^14.0.0 || ^15.0.0",
-    "next": "14.x.x || 15.x.x"
+    "next": "^15.3.0"
   },
   "peerDependenciesMeta": {
     "@fumadocs/mdx-remote": {