fumadocs-mdx 14.0.4 → 14.1.1

package/dist/{chunk-ED3ON275.js → chunk-STLEUNK7.js}

@@ -1,7 +1,8 @@
 import {
   createCodegen,
-  ident
-} from "./chunk-WBIHDYMN.js";
+  ident,
+  slash
+} from "./chunk-2PY3JUIC.js";
 import {
   fumaMatter
 } from "./chunk-VWJKRQZR.js";
@@ -11,32 +12,34 @@ import path2 from "path";
 import { glob } from "tinyglobby";
 
 // src/utils/fs-cache.ts
-import { LRUCache } from "lru-cache";
 import fs from "fs/promises";
 import path from "path";
-var map = new LRUCache({
-  max: 100
-});
+var map = /* @__PURE__ */ new Map();
+function createFSCache() {
+  return {
+    read(file) {
+      const fullPath = toFullPath(file);
+      const cached = map.get(fullPath);
+      if (cached) return cached;
+      const read = fs.readFile(fullPath).then((s) => s.toString());
+      map.set(fullPath, read);
+      return read;
+    },
+    delete(file) {
+      map.delete(toFullPath(file));
+    }
+  };
+}
 function toFullPath(file) {
   if (path.isAbsolute(file)) {
     return path.relative(process.cwd(), file);
   }
   return file;
 }
-function readFileWithCache(file) {
-  const fullPath = toFullPath(file);
-  const cached = map.get(fullPath);
-  if (cached) return cached;
-  const read = fs.readFile(fullPath).then((s) => s.toString());
-  map.set(fullPath, read);
-  return read;
-}
-function removeFileCache(file) {
-  map.delete(toFullPath(file));
-}
 
 // src/plugins/index-file.ts
 import { createHash } from "crypto";
+var indexFileCache = createFSCache();
 function indexFile(options = {}) {
   const {
     target = "default",
@@ -44,7 +47,6 @@ function indexFile(options = {}) {
     browser = true,
     dynamic = true
   } = options;
-  let config;
   let dynamicCollections;
   function isDynamic(collection) {
     return collection.type === "docs" && collection.docs.dynamic || collection.type === "doc" && collection.dynamic;
@@ -59,8 +61,8 @@ function indexFile(options = {}) {
       const indexFilePlugin = plugin["index-file"];
       if (!indexFilePlugin) continue;
       indexFilePlugin.serverOptions?.call(ctx, serverOptions);
-      const config2 = indexFilePlugin.generateTypeConfig?.call(ctx);
-      if (config2) typeConfigs.push(config2);
+      const config = indexFilePlugin.generateTypeConfig?.call(ctx);
+      if (config) typeConfigs.push(config);
     }
     return {
       serverOptions,
@@ -69,38 +71,38 @@ function indexFile(options = {}) {
   }
   return {
     name: "index-file",
-    config(v) {
-      config = v;
-      dynamicCollections = config.collectionList.filter(isDynamic);
+    config() {
+      dynamicCollections = this.core.getCollections().filter(isDynamic);
     },
     configureServer(server) {
       if (!server.watcher) return;
       server.watcher.on("all", async (event, file) => {
-        removeFileCache(file);
+        indexFileCache.delete(file);
         if (dynamicCollections.length === 0) {
           if (target === "vite") return;
           if (target === "default" && event === "change") return;
         }
-        const updatedCollection = config.collectionList.find(
-          (collection) => collection.hasFile(file)
-        );
+        const updatedCollection = this.core.getCollections().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 === "index-file"
+        await this.core.emit({
+          filterPlugin: (plugin) => plugin.name === "index-file",
+          filterWorkspace: () => false,
+          write: true
         });
       });
     },
     async emit() {
       const globCache = /* @__PURE__ */ new Map();
+      const { workspace, outDir } = this.core.getOptions();
       const { serverOptions, tc } = generateConfigs(this.core);
       const toEmitEntry = async (path3, content) => {
         const codegen = createCodegen({
           target,
-          outDir: this.outDir,
+          outDir,
           jsExtension: addJsExtension,
           globCache
         });
@@ -108,7 +110,8 @@ function indexFile(options = {}) {
           core: this.core,
           codegen,
           serverOptions,
-          tc
+          tc,
+          workspace: workspace?.name
         });
         return {
           path: path3,
@@ -126,12 +129,8 @@ function indexFile(options = {}) {
     }
   };
 }
-async function generateServerIndexFile({
-  core,
-  codegen,
-  serverOptions,
-  tc
-}) {
+async function generateServerIndexFile(ctx) {
+  const { core, codegen, serverOptions, tc } = ctx;
   codegen.lines.push(
     `import { server } from 'fumadocs-mdx/runtime/server';`,
     `import type * as Config from '${codegen.formatImportPath(core.getOptions().configPath)}';`,
@@ -139,51 +138,48 @@ async function generateServerIndexFile({
     `const create = server<typeof Config, ${tc}>(${JSON.stringify(serverOptions)});`
   );
   async function generateCollectionObject(collection) {
+    const base = getBase(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)
+            generateMetaCollectionGlob(ctx, collection.meta, true),
+            generateDocCollectionFrontmatterGlob(ctx, collection.docs, true),
+            generateDocCollectionGlob(ctx, collection.docs)
           ]);
-          return `await create.docsLazy("${collection.name}", "${collection.dir}", ${metaGlob2}, ${headGlob}, ${bodyGlob})`;
+          return `await create.docsLazy("${collection.name}", "${base}", ${metaGlob2}, ${headGlob}, ${bodyGlob})`;
         }
         const [metaGlob, docGlob] = await Promise.all([
-          generateMetaCollectionGlob(codegen, collection.meta, true),
-          generateDocCollectionGlob(codegen, collection.docs, true)
+          generateMetaCollectionGlob(ctx, collection.meta, true),
+          generateDocCollectionGlob(ctx, collection.docs, true)
         ]);
-        return `await create.docs("${collection.name}", "${collection.dir}", ${metaGlob}, ${docGlob})`;
+        return `await create.docs("${collection.name}", "${base}", ${metaGlob}, ${docGlob})`;
       }
       case "doc":
         if (collection.dynamic) return;
         if (collection.async) {
           const [headGlob, bodyGlob] = await Promise.all([
-            generateDocCollectionFrontmatterGlob(codegen, collection, true),
-            generateDocCollectionGlob(codegen, collection)
+            generateDocCollectionFrontmatterGlob(ctx, collection, true),
+            generateDocCollectionGlob(ctx, collection)
           ]);
-          return `await create.docLazy("${collection.name}", "${collection.dir}", ${headGlob}, ${bodyGlob})`;
+          return `await create.docLazy("${collection.name}", "${base}", ${headGlob}, ${bodyGlob})`;
         }
-        return `await create.doc("${collection.name}", "${collection.dir}", ${await generateDocCollectionGlob(
-          codegen,
+        return `await create.doc("${collection.name}", "${base}", ${await generateDocCollectionGlob(
+          ctx,
           collection,
           true
         )})`;
       case "meta":
-        return `await create.meta("${collection.name}", "${collection.dir}", ${await generateMetaCollectionGlob(
-          codegen,
+        return `await create.meta("${collection.name}", "${base}", ${await generateMetaCollectionGlob(
+          ctx,
           collection,
           true
         )})`;
     }
   }
   await codegen.pushAsync(
-    core.getConfig().collectionList.map(async (collection) => {
+    core.getCollections().map(async (collection) => {
       const obj = await generateCollectionObject(collection);
       if (!obj) return;
       return `
@@ -191,22 +187,23 @@ export const ${collection.name} = ${obj};`;
     })
   );
 }
-async function generateDynamicIndexFile({
-  core,
-  codegen,
-  serverOptions,
-  tc
-}) {
-  const { configPath } = core.getOptions();
+async function generateDynamicIndexFile(ctx) {
+  const { core, codegen, serverOptions, tc } = ctx;
+  const { configPath, environment, outDir } = core.getOptions();
+  const partialOptions = {
+    configPath,
+    environment,
+    outDir
+  };
   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)});`
+    `const create = await dynamic<typeof Config, ${tc}>(Config, ${JSON.stringify(partialOptions)}, ${JSON.stringify(serverOptions)});`
   );
-  async function generateCollectionObjectEntry(collection, file) {
-    const fullPath = path2.join(collection.dir, file);
-    const content = await readFileWithCache(fullPath).catch(() => "");
+  async function generateCollectionObjectEntry(collection, absolutePath) {
+    const fullPath = path2.relative(process.cwd(), absolutePath);
+    const content = await indexFileCache.read(fullPath).catch(() => "");
     const parsed = fumaMatter(content);
     const data = await core.transformFrontmatter(
       {
@@ -224,7 +221,7 @@ async function generateDynamicIndexFile({
     for (const [k, v] of Object.entries({
       info: {
         fullPath,
-        path: file
+        path: path2.relative(collection.dir, absolutePath)
       },
       data,
       hash
@@ -239,7 +236,8 @@ async function generateDynamicIndexFile({
     else if (parent.type === "docs") collection = parent.docs;
     if (!collection || !collection.dynamic) return;
     const files = await glob(collection.patterns, {
-      cwd: collection.dir
+      cwd: collection.dir,
+      absolute: true
     });
     const entries = await Promise.all(
       files.map((file) => generateCollectionObjectEntry(collection, file))
@@ -247,18 +245,18 @@ async function generateDynamicIndexFile({
     switch (parent.type) {
       case "docs": {
         const metaGlob = await generateMetaCollectionGlob(
-          codegen,
+          ctx,
           parent.meta,
           true
         );
-        return `await create.docs("${parent.name}", "${parent.dir}", ${metaGlob}, ${entries.join(", ")})`;
+        return `await create.docs("${parent.name}", "${getBase(parent)}", ${metaGlob}, ${entries.join(", ")})`;
       }
       case "doc":
-        return `await create.doc("${collection.name}", "${collection.dir}", ${entries.join(", ")})`;
+        return `await create.doc("${collection.name}", "${getBase(collection)}", ${entries.join(", ")})`;
     }
   }
   await codegen.pushAsync(
-    core.getConfig().collectionList.map(async (collection) => {
+    core.getCollections().map(async (collection) => {
       const obj = await generateCollectionObject(collection);
       if (!obj) return;
       return `
@@ -266,7 +264,8 @@ export const ${collection.name} = ${obj};`;
     })
   );
 }
-async function generateBrowserIndexFile({ core, codegen, tc }) {
+async function generateBrowserIndexFile(ctx) {
+  const { core, codegen, tc } = ctx;
   codegen.lines.push(
     `import { browser } from 'fumadocs-mdx/runtime/browser';`,
     `import type * as Config from '${codegen.formatImportPath(core.getOptions().configPath)}';`,
@@ -281,12 +280,12 @@ async function generateBrowserIndexFile({ core, codegen, tc }) {
       }
       case "doc":
         if (collection.dynamic) return;
-        return `create.doc("${collection.name}", ${await generateDocCollectionGlob(codegen, collection)})`;
+        return `create.doc("${collection.name}", ${await generateDocCollectionGlob(ctx, collection)})`;
     }
   }
   codegen.lines.push("const browserCollections = {");
   await codegen.pushAsync(
-    core.getConfig().collectionList.map(async (collection) => {
+    core.getCollections().map(async (collection) => {
       const obj = await generateCollectionObject(collection);
       if (!obj) return;
       return ident(`${collection.name}: ${obj},`);
@@ -294,30 +293,36 @@ async function generateBrowserIndexFile({ core, codegen, tc }) {
   );
   codegen.lines.push("};", "export default browserCollections;");
 }
-function generateDocCollectionFrontmatterGlob(codegen, collection, eager = false) {
+function getBase(collection) {
+  return slash(path2.relative(process.cwd(), collection.dir));
+}
+function generateDocCollectionFrontmatterGlob({ codegen, workspace }, collection, eager = false) {
   return codegen.generateGlobImport(collection.patterns, {
     query: {
       collection: collection.name,
-      only: "frontmatter"
+      only: "frontmatter",
+      workspace
     },
     import: "frontmatter",
     base: collection.dir,
     eager
   });
 }
-function generateDocCollectionGlob(codegen, collection, eager = false) {
+function generateDocCollectionGlob({ codegen, workspace }, collection, eager = false) {
   return codegen.generateGlobImport(collection.patterns, {
     query: {
-      collection: collection.name
+      collection: collection.name,
+      workspace
     },
     base: collection.dir,
     eager
   });
 }
-function generateMetaCollectionGlob(codegen, collection, eager = false) {
+function generateMetaCollectionGlob({ codegen, workspace }, collection, eager = false) {
   return codegen.generateGlobImport(collection.patterns, {
     query: {
-      collection: collection.name
+      collection: collection.name,
+      workspace
     },
     import: "default",
     base: collection.dir,

package/dist/{chunk-USWQVJWR.js → chunk-T6G5VOED.js}

@@ -12,14 +12,15 @@ import path from "path";
 import { createHash } from "crypto";
 var querySchema = z.object({
   only: z.literal(["frontmatter", "all"]).default("all"),
-  collection: z.string().optional()
+  collection: z.string().optional(),
+  workspace: z.string().optional()
 }).loose();
 var cacheEntry = z.object({
   code: z.string(),
   map: z.any().optional(),
   hash: z.string().optional()
 });
-function createMdxLoader(configLoader) {
+function createMdxLoader({ getCore }) {
   return {
     test: mdxLoaderGlob,
     async load({
@@ -29,14 +30,22 @@ function createMdxLoader(configLoader) {
       compiler,
       filePath
     }) {
-      const config = await configLoader.getConfig();
+      let core = await getCore();
       const value = await getSource();
       const matter = fumaMatter(value);
-      const parsed = querySchema.parse(query);
+      const {
+        collection: collectionName,
+        workspace,
+        only
+      } = querySchema.parse(query);
+      if (workspace) {
+        core = core.getWorkspaces().get(workspace) ?? core;
+      }
       let after;
-      if (!isDevelopment && config.global.experimentalBuildCache) {
-        const cacheDir = config.global.experimentalBuildCache;
-        const cacheKey = `${parsed.hash}_${parsed.collection ?? "global"}_${generateCacheHash(filePath)}`;
+      const { experimentalBuildCache = false } = core.getConfig().global;
+      if (!isDevelopment && experimentalBuildCache) {
+        const cacheDir = experimentalBuildCache;
+        const cacheKey = `${collectionName ?? "global"}_${generateCacheHash(filePath)}`;
         const cached = await fs.readFile(path.join(cacheDir, cacheKey)).then((content) => cacheEntry.parse(JSON.parse(content.toString()))).catch(() => null);
         if (cached && cached.hash === generateCacheHash(value)) return cached;
         after = async () => {
@@ -50,7 +59,7 @@ function createMdxLoader(configLoader) {
           );
         };
       }
-      const collection = parsed.collection ? config.getCollection(parsed.collection) : void 0;
+      const collection = collectionName ? core.getCollection(collectionName) : void 0;
       let docCollection;
       switch (collection?.type) {
         case "doc":
@@ -61,20 +70,20 @@ function createMdxLoader(configLoader) {
           break;
       }
       if (docCollection) {
-        matter.data = await configLoader.core.transformFrontmatter(
+        matter.data = await core.transformFrontmatter(
           { collection: docCollection, filePath, source: value },
           matter.data
         );
       }
-      if (parsed.only === "frontmatter") {
+      if (only === "frontmatter") {
         return {
           code: `export const frontmatter = ${JSON.stringify(matter.data)}`,
           map: null
         };
       }
       const lineOffset = isDevelopment ? countLines(matter.matter) : 0;
-      const { buildMDX } = await import("./build-mdx-W3233QBZ.js");
-      const compiled = await buildMDX(configLoader.core, docCollection, {
+      const { buildMDX } = await import("./build-mdx-RXJZQXGA.js");
+      const compiled = await buildMDX(core, docCollection, {
         isDevelopment,
         source: "\n".repeat(lineOffset) + matter.content,
         filePath,

package/dist/{chunk-NKIL543T.js → chunk-WSQ23PNV.js}

@@ -1,6 +1,6 @@
 import {
   ValidationError
-} from "./chunk-K4KWUM3J.js";
+} from "./chunk-KWSETXYC.js";
 
 // src/loaders/adapter.ts
 import { fileURLToPath } from "url";
@@ -134,7 +134,7 @@ function createStandaloneConfigLoader({
   buildConfig,
   mode
 }) {
-  let loaded;
+  let prev;
   async function getConfigHash() {
     if (mode === "production") return "static";
     const stats = await fs2.stat(core.getOptions().configPath).catch(() => {
@@ -142,31 +142,29 @@ function createStandaloneConfigLoader({
     });
     return stats.mtime.getTime().toString();
   }
-  async function newConfig() {
-    const { loadConfig } = await import("./load-from-file-OZ5N7DXU.js");
-    await core.init({
-      config: loadConfig(core, buildConfig)
-    });
-    return core.getConfig();
-  }
   return {
-    core,
-    async getConfig() {
+    async getCore() {
       const hash = await getConfigHash();
-      if (loaded && loaded.hash === hash) return loaded.config;
-      loaded = {
-        hash,
-        config: newConfig()
-      };
-      return loaded.config;
+      if (!prev || hash !== prev.hash) {
+        prev = {
+          hash,
+          init: (async () => {
+            const { loadConfig } = await import("./load-from-file-FHW724YY.js");
+            await core.init({
+              config: loadConfig(core, buildConfig)
+            });
+          })()
+        };
+      }
+      await prev.init;
+      return core;
     }
   };
 }
 function createIntegratedConfigLoader(core) {
   return {
-    core,
-    getConfig() {
-      return core.getConfig();
+    async getCore() {
+      return core;
     }
   };
 }

package/dist/{chunk-FBLMK4RS.js → chunk-Y7ISNZ7X.js}

@@ -8,6 +8,7 @@ import { visit as visit2 } from "unist-util-visit";
 import * as path from "path";
 import * as fs from "fs/promises";
 import { remarkHeading } from "fumadocs-core/mdx-plugins";
+import { VFile } from "vfile";
 
 // src/loaders/mdx/remark-unravel.ts
 import { visit } from "unist-util-visit";
@@ -127,19 +128,20 @@ function extractSection(root, section) {
 }
 function remarkInclude() {
   const TagName = "include";
-  const embedContent = async (file, heading, params, data) => {
+  const embedContent = async (targetPath, heading, params, parent) => {
+    const { _getProcessor = () => this, _compiler } = parent.data;
     let content;
     try {
-      content = (await fs.readFile(file)).toString();
+      content = (await fs.readFile(targetPath)).toString();
     } catch (e) {
       throw new Error(
-        `failed to read file ${file}
+        `failed to read file ${targetPath}
 ${e instanceof Error ? e.message : String(e)}`,
         { cause: e }
       );
     }
-    const ext = path.extname(file);
-    data._compiler?.addDependency(file);
+    const ext = path.extname(targetPath);
+    _compiler?.addDependency(targetPath);
     if (params.lang || ext !== ".md" && ext !== ".mdx") {
       const lang = params.lang ?? ext.slice(1);
       return {
@@ -150,13 +152,17 @@ ${e instanceof Error ? e.message : String(e)}`,
         data: {}
       };
     }
-    const parser = data._getProcessor ? data._getProcessor(ext === ".mdx" ? "mdx" : "md") : this;
+    const parser = _getProcessor(ext === ".mdx" ? "mdx" : "md");
     const parsed = fumaMatter(content);
-    let mdast = parser.parse({
-      path: file,
+    const targetFile = new VFile({
+      path: targetPath,
       value: parsed.content,
-      data: { frontmatter: parsed.data }
+      data: {
+        ...parent.data,
+        frontmatter: parsed.data
+      }
     });
+    let mdast = parser.parse(targetFile);
     const baseProcessor = unified().use(remarkMarkAndUnravel);
     if (heading) {
       const extracted = extractSection(
@@ -165,16 +171,16 @@ ${e instanceof Error ? e.message : String(e)}`,
       );
       if (!extracted)
         throw new Error(
-          `Cannot find section ${heading} in ${file}, make sure you have encapsulated the section in a <section id="${heading}"> tag, or a :::section directive with remark-directive configured.`
+          `Cannot find section ${heading} in ${targetPath}, make sure you have encapsulated the section in a <section id="${heading}"> tag, or a :::section directive with remark-directive configured.`
         );
       mdast = extracted;
     } else {
       mdast = await baseProcessor.run(mdast);
     }
-    await update(mdast, path.dirname(file), data);
+    await update(mdast, targetFile);
     return mdast;
   };
-  async function update(tree, directory, data) {
+  async function update(tree, file) {
     const queue = [];
     visit2(tree, ElementLikeTypes, (_node, _, parent) => {
       const node = _node;
@@ -183,12 +189,12 @@ ${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 = path.resolve(
-        "cwd" in attributes ? process.cwd() : directory,
+      const targetPath = path.resolve(
+        "cwd" in attributes ? file.cwd : file.dirname,
         relativePath
       );
       queue.push(
-        embedContent(file, section, attributes, data).then((replace) => {
+        embedContent(targetPath, section, attributes, file).then((replace) => {
           Object.assign(
             parent && parent.type === "paragraph" ? parent : node,
             replace
@@ -200,7 +206,7 @@ ${e instanceof Error ? e.message : String(e)}`,
     await Promise.all(queue);
   }
   return async (tree, file) => {
-    await update(tree, path.dirname(file.path), file.data);
+    await update(tree, file);
   };
 }
 

package/dist/{chunk-TYJDYTKH.js → chunk-ZAYZWFWP.js}

@@ -6,9 +6,10 @@ import {
 import { dump, load } from "js-yaml";
 import { z } from "zod";
 var querySchema = z.object({
-  collection: z.string().optional()
+  collection: z.string().optional(),
+  workspace: z.string().optional()
 }).loose();
-function createMetaLoader(configLoader, resolve = {}) {
+function createMetaLoader({ getCore }, resolve = {}) {
   const { json: resolveJson = "js", yaml: resolveYaml = "js" } = resolve;
   function parse(filePath, source) {
     try {
@@ -22,10 +23,13 @@ function createMetaLoader(configLoader, resolve = {}) {
   function onMeta(source, { filePath, query }) {
     const parsed = querySchema.safeParse(query);
     if (!parsed.success || !parsed.data.collection) return null;
-    const collectionName = parsed.data.collection;
+    const { collection: collectionName, workspace } = parsed.data;
     return async () => {
-      const config = await configLoader.getConfig();
-      const collection = config.getCollection(collectionName);
+      let core = await getCore();
+      if (workspace) {
+        core = core.getWorkspaces().get(workspace) ?? core;
+      }
+      const collection = core.getCollection(collectionName);
       let metaCollection;
       switch (collection?.type) {
         case "meta":
@@ -37,7 +41,7 @@ function createMetaLoader(configLoader, resolve = {}) {
       }
       const data = parse(filePath, source);
       if (!metaCollection) return data;
-      return configLoader.core.transformMeta(
+      return core.transformMeta(
         {
           collection: metaCollection,
           filePath,

package/dist/config/index.d.ts

@@ -1,10 +1,10 @@
-export { A as AnyCollection, B as BaseCollection, a as CollectionSchema, f as DefaultMDXOptions, D as DocCollection, b as DocsCollection, G as GlobalConfig, g as MDXPresetOptions, M as MetaCollection, P as PostprocessOptions, h as applyMdxPreset, d as defineCollections, e as defineConfig, c as defineDocs, i as frontmatterSchema, m as metaSchema } from '../core-C3QZSdEx.js';
+export { A as AnyCollection, B as BaseCollection, C as CollectionSchema, e as DefaultMDXOptions, D as DocCollection, a as DocsCollection, G as GlobalConfig, f as MDXPresetOptions, M as MetaCollection, P as PostprocessOptions, g as applyMdxPreset, d as defineCollections, c as defineConfig, b as defineDocs } from '../core-nagEel33.js';
 import { Processor, Transformer } from 'unified';
 import { Root } from 'mdast';
+export { pageSchema as frontmatterSchema, metaSchema } from 'fumadocs-core/source/schema';
 import '@mdx-js/mdx';
 import '@standard-schema/spec';
 import 'fumadocs-core/mdx-plugins';
-import 'zod';
 import 'chokidar';
 import 'vfile';
 import 'fumadocs-core/source';