fumadocs-mdx 14.0.3 → 14.1.0

package/dist/next/index.cjs

@@ -34,7 +34,7 @@ __export(next_exports, {
   postInstall: () => postInstall
 });
 module.exports = __toCommonJS(next_exports);
-var path5 = __toESM(require("path"), 1);
+var path6 = __toESM(require("path"), 1);
 
 // src/config/load-from-file.ts
 var import_node_url = require("url");
@@ -129,46 +129,57 @@ function applyMdxPreset(options = {}) {
 }
 
 // src/config/build.ts
+var import_node_path = __toESM(require("path"), 1);
 var SupportedFormats = {
   doc: ["mdx", "md"],
   meta: ["json", "yaml"]
 };
-function buildCollection(name, config) {
-  if (config.type === "docs") {
+function buildCollection(name, collection, cwd) {
+  if (collection.type === "docs") {
     return {
-      ...config,
+      ...collection,
+      type: "docs",
+      get dir() {
+        return this.docs.dir;
+      },
       name,
-      meta: buildPrimitiveCollection(name, config.meta),
-      docs: buildPrimitiveCollection(name, config.docs),
+      meta: buildCollection(name, collection.meta, cwd),
+      docs: buildCollection(name, collection.docs, cwd),
       hasFile(filePath) {
         return this.docs.hasFile(filePath) || this.meta.hasFile(filePath);
-      }
+      },
+      isFileSupported(filePath) {
+        return this.docs.isFileSupported(filePath) || this.meta.isFileSupported(filePath);
+      },
+      cwd
     };
   }
-  return buildPrimitiveCollection(name, config);
+  return {
+    ...collection,
+    ...buildPrimitiveCollection(name, collection, cwd)
+  };
 }
-function buildPrimitiveCollection(name, { files, ...config }) {
+function buildPrimitiveCollection(name, config, cwd) {
   const supportedFormats = SupportedFormats[config.type];
-  const patterns = files ?? [`**/*.{${supportedFormats.join(",")}}`];
-  let matchers;
+  const patterns = config.files ?? [`**/*.{${supportedFormats.join(",")}}`];
+  let matcher;
   return {
-    ...config,
+    dir: import_node_path.default.resolve(cwd, config.dir),
+    cwd,
     name,
     patterns,
     isFileSupported(filePath) {
       return supportedFormats.some((format) => filePath.endsWith(`.${format}`));
     },
     hasFile(filePath) {
-      matchers ??= (Array.isArray(config.dir) ? config.dir : [config.dir]).map(
-        (dir) => (0, import_picomatch.default)(patterns, {
-          cwd: dir
-        })
-      );
-      return this.isFileSupported(filePath) && matchers.some((matcher) => matcher(filePath));
+      if (!this.isFileSupported(filePath)) return false;
+      const relativePath = import_node_path.default.relative(this.dir, filePath);
+      if (relativePath.startsWith(`..${import_node_path.default.sep}`)) return false;
+      return (matcher ??= (0, import_picomatch.default)(patterns))(relativePath);
     }
   };
 }
-function buildConfig(config) {
+function buildConfig(config, cwd = process.cwd()) {
   const collections = /* @__PURE__ */ new Map();
   const loaded = {};
   for (const [k, v] of Object.entries(config)) {
@@ -176,15 +187,8 @@ function buildConfig(config) {
       continue;
     }
     if (typeof v === "object" && "type" in v) {
-      if (v.type === "docs") {
-        collections.set(k, buildCollection(k, v));
-        continue;
-      }
-      if (v.type === "doc" || v.type === "meta") {
-        collections.set(
-          k,
-          buildCollection(k, v)
-        );
+      if (v.type === "docs" || v.type === "doc" || v.type === "meta") {
+        collections.set(k, buildCollection(k, v, cwd));
         continue;
       }
     }
@@ -199,10 +203,18 @@ function buildConfig(config) {
   const mdxOptionsCache = /* @__PURE__ */ new Map();
   return {
     global: loaded,
-    collectionList: Array.from(collections.values()),
-    getCollection(name) {
-      return collections.get(name);
-    },
+    collections,
+    workspaces: Object.fromEntries(
+      Object.entries(loaded.workspaces ?? {}).map(([key, value]) => {
+        return [
+          key,
+          {
+            dir: value.dir,
+            config: buildConfig(value.config, import_node_path.default.resolve(cwd, value.dir))
+          }
+        ];
+      })
+    ),
     getMDXOptions(collection, environment = "bundler") {
       const key = collection ? `${environment}:${collection.name}` : environment;
       const cached = mdxOptionsCache.get(key);
@@ -256,6 +268,10 @@ async function loadConfig(core, build = false) {
   return await config;
 }
 
+// src/core.ts
+var import_node_path3 = __toESM(require("path"), 1);
+var import_promises = __toESM(require("fs/promises"), 1);
+
 // src/utils/validation.ts
 var ValidationError = class extends Error {
   constructor(message, issues) {
@@ -267,7 +283,8 @@ ${issues.map((issue) => `  ${issue.path}: ${issue.message}`).join("\n")}`
     this.issues = issues;
   }
   async toStringFormatted() {
-    const picocolors = await import("picocolors");
+    const picocolorsModule = await import("picocolors");
+    const picocolors = picocolorsModule.default ?? picocolorsModule;
     return [
       picocolors.bold(`[MDX] ${this.title}:`),
       ...this.issues.map(
@@ -294,12 +311,8 @@ async function validate(schema, data, context, errorMessage) {
   return data;
 }
 
-// src/core.ts
-var import_node_path2 = __toESM(require("path"), 1);
-var import_promises = __toESM(require("fs/promises"), 1);
-
 // src/utils/codegen.ts
-var import_node_path = __toESM(require("path"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
 var import_tinyglobby = require("tinyglobby");
 function createCodegen({
   target = "default",
@@ -339,7 +352,7 @@ function createCodegen({
       );
       return `import.meta.glob(${JSON.stringify(patterns)}, ${JSON.stringify(
         {
-          base: normalizeViteGlobPath(import_node_path.default.relative(outDir, base)),
+          base: normalizeViteGlobPath(import_node_path2.default.relative(outDir, base)),
           ...rest
         },
         null,
@@ -362,10 +375,10 @@ function createCodegen({
       }
       let code = "{";
       for (const item of await files) {
-        const fullPath = import_node_path.default.join(base, item);
+        const fullPath = import_node_path2.default.join(base, item);
         const searchParams = new URLSearchParams();
         for (const [k, v] of Object.entries(query)) {
-          searchParams.set(k, v);
+          if (v !== void 0) searchParams.set(k, v);
         }
         const importPath = this.formatImportPath(fullPath) + "?" + searchParams.toString();
         if (eager) {
@@ -386,16 +399,15 @@ function createCodegen({
       return code;
     },
     formatImportPath(file) {
-      const ext = import_node_path.default.extname(file);
+      const ext = import_node_path2.default.extname(file);
       let filename;
-      if (ext === ".ts" && jsExtension) {
-        filename = file.substring(0, file.length - ext.length) + ".js";
-      } else if (ext === ".ts") {
+      if (ext === ".ts") {
         filename = file.substring(0, file.length - ext.length);
+        if (jsExtension) filename += ".js";
       } else {
         filename = file;
       }
-      const importPath = slash(import_node_path.default.relative(outDir, filename));
+      const importPath = slash(import_node_path2.default.relative(outDir, filename));
       return importPath.startsWith(".") ? importPath : `./${importPath}`;
     },
     toString() {
@@ -409,12 +421,12 @@ function normalizeViteGlobPath(file) {
   if (file.startsWith("/")) return `.${file}`;
   return `./${file}`;
 }
-function slash(path6) {
-  const isExtendedLengthPath = path6.startsWith("\\\\?\\");
+function slash(path7) {
+  const isExtendedLengthPath = path7.startsWith("\\\\?\\");
   if (isExtendedLengthPath) {
-    return path6;
+    return path7;
   }
-  return path6.replaceAll("\\", "/");
+  return path7.replaceAll("\\", "/");
 }
 function ident(code, tab = 1) {
   return code.split("\n").map((v) => "  ".repeat(tab) + v).join("\n");
@@ -434,9 +446,10 @@ async function getPlugins(pluginOptions) {
   }
   return plugins;
 }
-function createCore(options, defaultPlugins = []) {
+function createCore(options) {
   let config;
   let plugins;
+  const workspaces = /* @__PURE__ */ new Map();
   async function transformMetadata({
     collection,
     filePath,
@@ -452,7 +465,7 @@ function createCore(options, defaultPlugins = []) {
     }
     return data;
   }
-  const core = {
+  return {
     /**
      * Convenient cache store, reset when config changes
      */
@@ -460,15 +473,36 @@ function createCore(options, defaultPlugins = []) {
     async init({ config: newConfig }) {
       config = await newConfig;
       this.cache.clear();
+      workspaces.clear();
       plugins = await getPlugins([
         postprocessPlugin(),
-        ...defaultPlugins,
-        ...config.global.plugins ?? []
+        options.plugins,
+        config.global.plugins
       ]);
       for (const plugin of plugins) {
-        const out = await plugin.config?.call(pluginContext, config);
+        const out = await plugin.config?.call(this.getPluginContext(), config);
         if (out) config = out;
       }
+      if (!options.workspace) {
+        await Promise.all(
+          Object.entries(config.workspaces).map(async ([name, workspace]) => {
+            const core = createCore({
+              ...options,
+              outDir: import_node_path3.default.join(options.outDir, name),
+              workspace: {
+                name,
+                parent: this,
+                dir: workspace.dir
+              }
+            });
+            await core.init({ config: workspace.config });
+            workspaces.set(name, core);
+          })
+        );
+      }
+    },
+    getWorkspaces() {
+      return workspaces;
     },
     getOptions() {
       return options;
@@ -480,42 +514,74 @@ function createCore(options, defaultPlugins = []) {
      * The file path of compiled config file, the file may not exist (e.g. on Vite, or still compiling)
      */
     getCompiledConfigPath() {
-      return import_node_path2.default.join(options.outDir, "source.config.mjs");
+      return import_node_path3.default.join(options.outDir, "source.config.mjs");
     },
     getPlugins() {
       return plugins;
     },
+    getCollections() {
+      return Array.from(config.collections.values());
+    },
+    getCollection(name) {
+      return config.collections.get(name);
+    },
     getPluginContext() {
-      return pluginContext;
+      return {
+        core: this
+      };
     },
     async initServer(server) {
+      const ctx = this.getPluginContext();
       for (const plugin of plugins) {
-        await plugin.configureServer?.call(pluginContext, server);
+        await plugin.configureServer?.call(ctx, server);
+      }
+      for (const workspace of workspaces.values()) {
+        await workspace.initServer(server);
       }
     },
-    async emit({ filterPlugin = () => true } = {}) {
-      return (await Promise.all(
-        plugins.map((plugin) => {
-          if (!filterPlugin(plugin) || !plugin.emit) return [];
-          return plugin.emit.call(pluginContext);
-        })
-      )).flat();
-    },
-    async emitAndWrite(emitOptions) {
+    async emit(emitOptions = {}) {
+      const { filterPlugin, filterWorkspace, write = false } = emitOptions;
       const start = performance.now();
-      const out = await this.emit(emitOptions);
-      await Promise.all(
-        out.map(async (entry) => {
-          const file = import_node_path2.default.join(options.outDir, entry.path);
-          await import_promises.default.mkdir(import_node_path2.default.dirname(file), { recursive: true });
-          await import_promises.default.writeFile(file, entry.content);
+      const ctx = this.getPluginContext();
+      const added = /* @__PURE__ */ new Set();
+      const out = {
+        entries: [],
+        workspaces: {}
+      };
+      for (const li of await Promise.all(
+        plugins.map((plugin) => {
+          if (filterPlugin && !filterPlugin(plugin) || !plugin.emit) return;
+          return plugin.emit.call(ctx);
         })
-      );
-      console.log(`[MDX] generated files in ${performance.now() - start}ms`);
+      )) {
+        if (!li) continue;
+        for (const item of li) {
+          if (added.has(item.path)) continue;
+          out.entries.push(item);
+          added.add(item.path);
+        }
+      }
+      if (write) {
+        await Promise.all(
+          out.entries.map(async (entry) => {
+            const file = import_node_path3.default.join(options.outDir, entry.path);
+            await import_promises.default.mkdir(import_node_path3.default.dirname(file), { recursive: true });
+            await import_promises.default.writeFile(file, entry.content);
+          })
+        );
+        console.log(
+          options.workspace ? `[MDX: ${options.workspace.name}] generated files in ${performance.now() - start}ms` : `[MDX] generated files in ${performance.now() - start}ms`
+        );
+      }
+      for (const [name, workspace] of workspaces) {
+        if (filterWorkspace && !filterWorkspace(name)) continue;
+        out.workspaces[name] = (await workspace.emit(emitOptions)).entries;
+      }
+      return out;
     },
     async transformMeta(options2, data) {
       const ctx = {
-        ...pluginContext,
+        ...this.getPluginContext(),
         ...options2
       };
       data = await transformMetadata(options2, data);
@@ -527,7 +593,7 @@ function createCore(options, defaultPlugins = []) {
     },
     async transformFrontmatter(options2, data) {
       const ctx = {
-        ...pluginContext,
+        ...this.getPluginContext(),
         ...options2
       };
       data = await transformMetadata(options2, data);
@@ -539,7 +605,7 @@ function createCore(options, defaultPlugins = []) {
     },
     async transformVFile(options2, file) {
       const ctx = {
-        ...pluginContext,
+        ...this.getPluginContext(),
         ...options2
       };
       for (const plugin of plugins) {
@@ -549,11 +615,6 @@ function createCore(options, defaultPlugins = []) {
       return file;
     }
   };
-  const pluginContext = {
-    core,
-    ...options
-  };
-  return core;
 }
 function postprocessPlugin() {
   const LinkReferenceTypes = `{
@@ -568,7 +629,7 @@ function postprocessPlugin() {
         const lines = [];
         lines.push("{");
         lines.push("  DocData: {");
-        for (const collection of this.core.getConfig().collectionList) {
+        for (const collection of this.core.getCollections()) {
           let postprocessOptions;
           switch (collection.type) {
             case "doc":
@@ -604,29 +665,30 @@ var import_path = __toESM(require("path"), 1);
 var import_tinyglobby2 = require("tinyglobby");
 
 // src/utils/fs-cache.ts
-var import_lru_cache = require("lru-cache");
 var import_promises2 = __toESM(require("fs/promises"), 1);
-var import_node_path3 = __toESM(require("path"), 1);
-var map = new import_lru_cache.LRUCache({
-  max: 100
-});
+var import_node_path4 = __toESM(require("path"), 1);
+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 = import_promises2.default.readFile(fullPath).then((s) => s.toString());
+      map.set(fullPath, read);
+      return read;
+    },
+    delete(file) {
+      map.delete(toFullPath(file));
+    }
+  };
+}
 function toFullPath(file) {
-  if (import_node_path3.default.isAbsolute(file)) {
-    return import_node_path3.default.relative(process.cwd(), file);
+  if (import_node_path4.default.isAbsolute(file)) {
+    return import_node_path4.default.relative(process.cwd(), file);
   }
   return file;
 }
-function readFileWithCache(file) {
-  const fullPath = toFullPath(file);
-  const cached = map.get(fullPath);
-  if (cached) return cached;
-  const read = import_promises2.default.readFile(fullPath).then((s) => s.toString());
-  map.set(fullPath, read);
-  return read;
-}
-function removeFileCache(file) {
-  map.delete(toFullPath(file));
-}
 
 // src/plugins/index-file.ts
 var import_crypto = require("crypto");
@@ -648,6 +710,7 @@ function fumaMatter(input) {
 }
 
 // src/plugins/index-file.ts
+var indexFileCache = createFSCache();
 function indexFile(options = {}) {
   const {
     target = "default",
@@ -655,7 +718,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;
@@ -670,8 +732,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,
@@ -680,38 +742,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 (path6, content) => {
+      const toEmitEntry = async (path7, content) => {
         const codegen = createCodegen({
           target,
-          outDir: this.outDir,
+          outDir,
           jsExtension: addJsExtension,
           globCache
         });
@@ -719,10 +781,11 @@ function indexFile(options = {}) {
           core: this.core,
           codegen,
           serverOptions,
-          tc
+          tc,
+          workspace: workspace?.name
         });
         return {
-          path: path6,
+          path: path7,
           content: codegen.toString()
         };
       };
@@ -737,12 +800,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)}';`,
@@ -750,51 +809,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 `
@@ -802,22 +858,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 = import_path.default.join(collection.dir, file);
-    const content = await readFileWithCache(fullPath).catch(() => "");
+  async function generateCollectionObjectEntry(collection, absolutePath) {
+    const fullPath = import_path.default.relative(process.cwd(), absolutePath);
+    const content = await indexFileCache.read(fullPath).catch(() => "");
     const parsed = fumaMatter(content);
     const data = await core.transformFrontmatter(
       {
@@ -835,7 +892,7 @@ async function generateDynamicIndexFile({
     for (const [k, v] of Object.entries({
       info: {
         fullPath,
-        path: file
+        path: import_path.default.relative(collection.dir, absolutePath)
       },
       data,
       hash
@@ -850,7 +907,8 @@ async function generateDynamicIndexFile({
     else if (parent.type === "docs") collection = parent.docs;
     if (!collection || !collection.dynamic) return;
     const files = await (0, import_tinyglobby2.glob)(collection.patterns, {
-      cwd: collection.dir
+      cwd: collection.dir,
+      absolute: true
     });
     const entries = await Promise.all(
       files.map((file) => generateCollectionObjectEntry(collection, file))
@@ -858,18 +916,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 `
@@ -877,7 +935,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)}';`,
@@ -892,12 +951,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},`);
@@ -905,30 +964,36 @@ async function generateBrowserIndexFile({ core, codegen, tc }) {
   );
   codegen.lines.push("};", "export default browserCollections;");
 }
-function generateDocCollectionFrontmatterGlob(codegen, collection, eager = false) {
+function getBase(collection) {
+  return import_path.default.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,
@@ -946,9 +1011,11 @@ function createMDX(createOptions = {}) {
     void init(isDev, core);
   }
   return (nextConfig = {}) => {
+    const { configPath, outDir } = core.getOptions();
     const loaderOptions = {
-      ...core.getOptions(),
-      absoluteCompiledConfigPath: path5.resolve(core.getCompiledConfigPath()),
+      configPath,
+      outDir,
+      absoluteCompiledConfigPath: path6.resolve(core.getCompiledConfigPath()),
       isDev
     };
     const turbopack = {
@@ -1025,7 +1092,7 @@ async function init(dev, core) {
     await core.init({
       config: loadConfig(core, true)
     });
-    await core.emitAndWrite();
+    await core.emit({ write: true });
   }
   async function devServer() {
     const { FSWatcher } = await import("chokidar");
@@ -1036,20 +1103,20 @@ async function init(dev, core) {
       ignored: [outDir]
     });
     watcher.add(configPath);
-    for (const collection of core.getConfig().collectionList) {
-      if (collection.type === "docs") {
-        watcher.add(collection.docs.dir);
-        watcher.add(collection.meta.dir);
-      } else {
+    for (const collection of core.getCollections()) {
+      watcher.add(collection.dir);
+    }
+    for (const workspace of core.getWorkspaces().values()) {
+      for (const collection of workspace.getCollections()) {
         watcher.add(collection.dir);
       }
     }
     watcher.on("ready", () => {
       console.log("[MDX] started dev server");
     });
-    const absoluteConfigPath = path5.resolve(configPath);
+    const absoluteConfigPath = path6.resolve(configPath);
     watcher.on("all", async (_event, file) => {
-      if (path5.resolve(file) === absoluteConfigPath) {
+      if (path6.resolve(file) === absoluteConfigPath) {
         watcher.removeAllListeners();
         await watcher.close();
         await initOrReload();
@@ -1074,7 +1141,7 @@ async function postInstall(options) {
   await core.init({
     config: loadConfig(core, true)
   });
-  await core.emitAndWrite();
+  await core.emit({ write: true });
 }
 function applyDefaults(options) {
   return {
@@ -1084,28 +1151,12 @@ function applyDefaults(options) {
   };
 }
 function createNextCore(options) {
-  const core = createCore(
-    {
-      environment: "next",
-      outDir: options.outDir,
-      configPath: options.configPath
-    },
-    [options.index && indexFile(options.index)]
-  );
-  return {
-    ...core,
-    async emitAndWrite(...args) {
-      try {
-        await core.emitAndWrite(...args);
-      } catch (err) {
-        if (err instanceof ValidationError) {
-          console.error(await err.toStringFormatted());
-        } else {
-          console.error(err);
-        }
-      }
-    }
-  };
+  return createCore({
+    environment: "next",
+    outDir: options.outDir,
+    configPath: options.configPath,
+    plugins: [options.index && indexFile(options.index)]
+  });
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {