fumadocs-mdx 14.0.4 → 14.1.0

package/dist/{build-mdx-W3233QBZ.js → build-mdx-RXJZQXGA.js}

@@ -1,7 +1,7 @@
 import {
   buildMDX
-} from "./chunk-KOPLIEVQ.js";
-import "./chunk-FBLMK4RS.js";
+} from "./chunk-7W73RILB.js";
+import "./chunk-Y7ISNZ7X.js";
 import "./chunk-VWJKRQZR.js";
 export {
   buildMDX

package/dist/bun/index.d.ts

@@ -1,10 +1,10 @@
 import { BunPlugin } from 'bun';
-import { C as CoreOptions } from '../core-C3QZSdEx.js';
+import { C as CoreOptions } from '../core-X5ggQtBM.js';
 import '@mdx-js/mdx';
 import '@standard-schema/spec';
 import 'unified';
 import 'fumadocs-core/mdx-plugins';
-import 'zod';
+import 'fumadocs-core/source/schema';
 import 'chokidar';
 import 'vfile';
 import 'fumadocs-core/source';

package/dist/bun/index.js

@@ -1,23 +1,23 @@
 import {
   buildConfig
-} from "../chunk-6RPNS75C.js";
+} from "../chunk-OLD35ARB.js";
 import "../chunk-S7KOJHHO.js";
 import {
   createMdxLoader
-} from "../chunk-USWQVJWR.js";
+} from "../chunk-T6G5VOED.js";
 import {
   createMetaLoader
-} from "../chunk-TYJDYTKH.js";
+} from "../chunk-ZAYZWFWP.js";
 import {
   createIntegratedConfigLoader,
   toBun
-} from "../chunk-NKIL543T.js";
+} from "../chunk-WAAWFNDX.js";
 import "../chunk-4JSFLXXT.js";
 import {
   _Defaults,
   createCore
-} from "../chunk-K4KWUM3J.js";
-import "../chunk-WBIHDYMN.js";
+} from "../chunk-VKSHE52K.js";
+import "../chunk-PW2AZGGD.js";
 import "../chunk-VWJKRQZR.js";
 
 // src/bun/index.ts

package/dist/{chunk-KOPLIEVQ.js → chunk-7W73RILB.js}

@@ -1,7 +1,7 @@
 import {
   flattenNode,
   remarkInclude
-} from "./chunk-FBLMK4RS.js";
+} from "./chunk-Y7ISNZ7X.js";
 
 // src/loaders/mdx/build-mdx.ts
 import { createProcessor } from "@mdx-js/mdx";
@@ -159,6 +159,7 @@ async function buildMDX(core, collection, {
   let vfile = new VFile({
     value: source,
     path: filePath,
+    cwd: collection?.cwd,
     data: { frontmatter, _compiler, _getProcessor: getProcessor }
   });
   if (collection) {

package/dist/{chunk-LPX7ZO66.js → chunk-DTFUANSF.js}

@@ -1,6 +1,6 @@
 import {
   buildConfig
-} from "./chunk-6RPNS75C.js";
+} from "./chunk-OLD35ARB.js";
 
 // src/config/load-from-file.ts
 import { pathToFileURL } from "url";

package/dist/{chunk-CGGDM5F3.js → chunk-K7N6GD4M.js}

@@ -1,6 +1,6 @@
 import {
   createCore
-} from "./chunk-K4KWUM3J.js";
+} from "./chunk-VKSHE52K.js";
 
 // src/webpack/index.ts
 var core;

package/dist/{chunk-6RPNS75C.js → chunk-OLD35ARB.js}

@@ -4,46 +4,57 @@ import {
 
 // src/config/build.ts
 import picomatch from "picomatch";
+import path from "path";
 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: path.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) => picomatch(patterns, {
-          cwd: dir
-        })
-      );
-      return this.isFileSupported(filePath) && matchers.some((matcher) => matcher(filePath));
+      if (!this.isFileSupported(filePath)) return false;
+      const relativePath = path.relative(this.dir, filePath);
+      if (relativePath.startsWith(`..${path.sep}`)) return false;
+      return (matcher ??= picomatch(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)) {
@@ -51,15 +62,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;
       }
     }
@@ -74,10 +78,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, path.resolve(cwd, value.dir))
+          }
+        ];
+      })
+    ),
     getMDXOptions(collection, environment = "bundler") {
       const key = collection ? `${environment}:${collection.name}` : environment;
       const cached = mdxOptionsCache.get(key);

package/dist/{chunk-WBIHDYMN.js → chunk-PW2AZGGD.js}

@@ -65,7 +65,7 @@ function createCodegen({
         const fullPath = path.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) {
@@ -88,10 +88,9 @@ function createCodegen({
     formatImportPath(file) {
       const ext = path.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;
       }

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-ED3ON275.js → chunk-VITVHHR6.js}

@@ -1,7 +1,7 @@
 import {
   createCodegen,
   ident
-} from "./chunk-WBIHDYMN.js";
+} from "./chunk-PW2AZGGD.js";
 import {
   fumaMatter
 } from "./chunk-VWJKRQZR.js";
@@ -11,32 +11,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 +46,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 +60,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 +70,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 +109,8 @@ function indexFile(options = {}) {
           core: this.core,
           codegen,
           serverOptions,
-          tc
+          tc,
+          workspace: workspace?.name
         });
         return {
           path: path3,
@@ -126,12 +128,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 +137,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 +186,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 +220,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 +235,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 +244,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 +263,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 +279,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 +292,36 @@ async function generateBrowserIndexFile({ core, codegen, tc }) {
   );
   codegen.lines.push("};", "export default browserCollections;");
 }
-function generateDocCollectionFrontmatterGlob(codegen, collection, eager = false) {
+function getBase(collection) {
+  return 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,