@mastra/deployer 0.16.4-alpha.1 → 0.17.0-alpha.3

package/dist/{chunk-T4L3WY7M.cjs → chunk-M54YPGM4.cjs}

@@ -2,25 +2,29 @@
 
 var chunkHR2HOA5D_cjs = require('./chunk-HR2HOA5D.cjs');
 var babel = require('@babel/core');
-var commonjs2 = require('@rollup/plugin-commonjs');
-var json2 = require('@rollup/plugin-json');
-var nodeResolve = require('@rollup/plugin-node-resolve');
-var virtual = require('@rollup/plugin-virtual');
-var esmShim = require('@rollup/plugin-esm-shim');
 var fs = require('fs');
 var promises = require('fs/promises');
-var url = require('url');
+var path2 = require('path');
+var child_process = require('child_process');
 var rollup = require('rollup');
 var originalEsbuild = require('rollup-plugin-esbuild');
-var module$1 = require('module');
-var path = require('path');
-var child_process = require('child_process');
+var commonjs = require('@rollup/plugin-commonjs');
+var resolveFrom2 = require('resolve-from');
 var typescriptPaths = require('typescript-paths');
 var rollupPlugin = require('@optimize-lodash/rollup-plugin');
-var localPkg = require('local-pkg');
+var json = require('@rollup/plugin-json');
 var slugify = require('@sindresorhus/slugify');
+var pkg = require('empathic/package');
 var findWorkspaces = require('find-workspaces');
 var fsExtra = require('fs-extra');
+var logger = require('@mastra/core/logger');
+var virtual = require('@rollup/plugin-virtual');
+var url = require('url');
+var module$1 = require('module');
+var localPkg = require('local-pkg');
+var nodeResolve = require('@rollup/plugin-node-resolve');
+var esmShim = require('@rollup/plugin-esm-shim');
+var posix = require('path/posix');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -43,113 +47,18 @@ function _interopNamespace(e) {
 }
 
 var babel__namespace = /*#__PURE__*/_interopNamespace(babel);
-var commonjs2__default = /*#__PURE__*/_interopDefault(commonjs2);
-var json2__default = /*#__PURE__*/_interopDefault(json2);
-var nodeResolve__default = /*#__PURE__*/_interopDefault(nodeResolve);
-var virtual__default = /*#__PURE__*/_interopDefault(virtual);
-var esmShim__default = /*#__PURE__*/_interopDefault(esmShim);
 var fs__default = /*#__PURE__*/_interopDefault(fs);
+var path2__namespace = /*#__PURE__*/_interopNamespace(path2);
 var originalEsbuild__default = /*#__PURE__*/_interopDefault(originalEsbuild);
-var path__default = /*#__PURE__*/_interopDefault(path);
+var commonjs__default = /*#__PURE__*/_interopDefault(commonjs);
+var resolveFrom2__default = /*#__PURE__*/_interopDefault(resolveFrom2);
+var json__default = /*#__PURE__*/_interopDefault(json);
 var slugify__default = /*#__PURE__*/_interopDefault(slugify);
+var pkg__namespace = /*#__PURE__*/_interopNamespace(pkg);
+var virtual__default = /*#__PURE__*/_interopDefault(virtual);
+var nodeResolve__default = /*#__PURE__*/_interopDefault(nodeResolve);
+var esmShim__default = /*#__PURE__*/_interopDefault(esmShim);
 
-function esbuild(options = {}) {
-  return originalEsbuild__default.default({
-    target: "node20",
-    platform: "node",
-    minify: false,
-    ...options
-  });
-}
-function isNodeBuiltin(dep) {
-  const [pkg] = dep.split("/");
-  return dep.startsWith("node:") || module$1.builtinModules.includes(dep) || module$1.builtinModules.includes(pkg);
-}
-function aliasHono() {
-  return {
-    name: "hono-alias",
-    resolveId(id) {
-      if (!id.startsWith("@hono/") && !id.startsWith("hono/") && id !== "hono" && id !== "hono-openapi") {
-        return;
-      }
-      const path2 = undefined(id);
-      return url.fileURLToPath(path2);
-    }
-  };
-}
-function removeDeployer() {
-  const t = babel__namespace.default.types;
-  return {
-    name: "remove-deployer",
-    visitor: {
-      NewExpression(path2, state) {
-        const varDeclaratorPath = path2.findParent((path3) => t.isVariableDeclarator(path3.node));
-        if (!varDeclaratorPath) {
-          return;
-        }
-        const parentNode = path2.parentPath.node;
-        if (!t.isVariableDeclarator(parentNode) || !t.isIdentifier(parentNode.id) || parentNode.id.name !== "mastra") {
-          return;
-        }
-        if (!state.hasReplaced) {
-          state.hasReplaced = true;
-          const newMastraObj = t.cloneNode(path2.node);
-          if (t.isObjectExpression(newMastraObj.arguments[0]) && newMastraObj.arguments[0].properties?.[0]) {
-            const deployer = newMastraObj.arguments[0].properties.find(
-              (prop) => t.isObjectProperty(prop) && t.isIdentifier(prop.key) && prop.key.name === "deployer"
-            );
-            if (!deployer) {
-              return;
-            }
-            newMastraObj.arguments[0].properties = newMastraObj.arguments[0].properties.filter(
-              (prop) => prop !== deployer
-            );
-            if (t.isObjectProperty(deployer) && t.isIdentifier(deployer.value)) {
-              const deployerBinding = state.file.scope.getBinding(deployer.value.name);
-              if (deployerBinding) {
-                deployerBinding?.path?.parentPath?.remove();
-              }
-            }
-            path2.replaceWith(newMastraObj);
-          }
-        }
-      }
-    }
-  };
-}
-
-// src/build/plugins/remove-deployer.ts
-function removeDeployer2(mastraEntry, options) {
-  return {
-    name: "remove-deployer",
-    transform(code, id) {
-      if (id !== mastraEntry) {
-        return;
-      }
-      return new Promise((resolve, reject) => {
-        babel__namespace.transform(
-          code,
-          {
-            babelrc: false,
-            configFile: false,
-            filename: id,
-            plugins: [removeDeployer],
-            sourceMaps: options?.sourcemap
-          },
-          (err, result) => {
-            if (err) {
-              return reject(err);
-            }
-            resolve({
-              code: result.code,
-              map: result.map
-            });
-          }
-        );
-      });
-    }
-  };
-}
 function spawn(command, args = [], options = {}) {
   return new Promise((resolve, reject) => {
     const childProcess = child_process.spawn(command, args, {
@@ -183,80 +92,10 @@ function validate(file) {
       `import('file://${file.replaceAll("\\", "/")}')`
     ],
     {
-      cwd: path.dirname(file)
+      cwd: path2.dirname(file)
     }
   );
 }
-var PLUGIN_NAME = "tsconfig-paths";
-function tsConfigPaths({ tsConfigPath, respectCoreModule, localResolve } = {}) {
-  let handler;
-  return {
-    name: PLUGIN_NAME,
-    buildStart() {
-      handler = typescriptPaths.createHandler({
-        log: () => {
-        },
-        tsConfigPath,
-        respectCoreModule,
-        falllback: (moduleName) => fs__default.default.existsSync(moduleName)
-      });
-      return;
-    },
-    async resolveId(request, importer, options) {
-      if (!importer || request.startsWith("\0")) {
-        return null;
-      }
-      const moduleName = handler?.(request, path.normalize(importer));
-      if (!moduleName) {
-        let importerMeta = {};
-        const resolved = await this.resolve(request, importer, { skipSelf: true, ...options });
-        if (!resolved) {
-          return null;
-        }
-        if (localResolve) {
-          const importerInfo = this.getModuleInfo(importer);
-          importerMeta = importerInfo?.meta || {};
-          if (!request.startsWith("./") && !request.startsWith("../") && importerMeta?.[PLUGIN_NAME]?.resolved) {
-            return {
-              ...resolved,
-              external: !request.startsWith("hono/") && request !== "hono"
-            };
-          }
-        }
-        return {
-          ...resolved,
-          meta: {
-            ...resolved.meta || {},
-            ...importerMeta
-          }
-        };
-      }
-      if (!path__default.default.extname(moduleName)) {
-        const resolved = await this.resolve(moduleName, importer, { skipSelf: true, ...options });
-        if (!resolved) {
-          return null;
-        }
-        return {
-          ...resolved,
-          meta: {
-            ...resolved.meta,
-            [PLUGIN_NAME]: {
-              resolved: true
-            }
-          }
-        };
-      }
-      return {
-        id: moduleName,
-        meta: {
-          [PLUGIN_NAME]: {
-            resolved: true
-          }
-        }
-      };
-    }
-  };
-}
 function removeAllOptionsFromMastraExcept(result, option, logger) {
   const t = babel__namespace.default.types;
   return {
@@ -264,29 +103,29 @@ function removeAllOptionsFromMastraExcept(result, option, logger) {
     visitor: {
       ExportNamedDeclaration: {
         // remove all exports
-        exit(path2) {
-          path2.remove();
+        exit(path3) {
+          path3.remove();
         }
       },
-      NewExpression(path2, state) {
-        const varDeclaratorPath = path2.findParent((path3) => t.isVariableDeclarator(path3.node));
+      NewExpression(path3, state) {
+        const varDeclaratorPath = path3.findParent((path4) => t.isVariableDeclarator(path4.node));
         if (!varDeclaratorPath) {
           return;
         }
-        const parentNode = path2.parentPath.node;
+        const parentNode = path3.parentPath.node;
         if (!t.isVariableDeclarator(parentNode) || !t.isIdentifier(parentNode.id) || parentNode.id.name !== "mastra") {
           return;
         }
         let mastraArgs = t.objectExpression([]);
-        if (t.isObjectExpression(path2.node.arguments[0])) {
-          mastraArgs = path2.node.arguments[0];
+        if (t.isObjectExpression(path3.node.arguments[0])) {
+          mastraArgs = path3.node.arguments[0];
         }
         let telemetry = mastraArgs.properties.find(
           // @ts-ignore
           (prop) => prop.key.name === option
         );
         let telemetryValue = t.objectExpression([]);
-        const programPath = path2.scope.getProgramParent().path;
+        const programPath = path3.scope.getProgramParent().path;
         if (!programPath) {
           return;
         }
@@ -296,7 +135,7 @@ function removeAllOptionsFromMastraExcept(result, option, logger) {
           if (t.isIdentifier(telemetry.value) && telemetry.value.name === option) {
             const telemetryBinding = state.file.scope.getBinding(option);
             if (telemetryBinding && t.isVariableDeclarator(telemetryBinding.path.node)) {
-              const id = path2.scope.generateUidIdentifier(option);
+              const id = path3.scope.generateUidIdentifier(option);
               telemetryBinding.path.replaceWith(t.variableDeclarator(id, telemetryBinding.path.node.init));
               telemetryValue = id;
             }
@@ -309,8 +148,8 @@ function removeAllOptionsFromMastraExcept(result, option, logger) {
         programPath.node.body.push(exportDeclaration);
       },
       Program: {
-        exit(path2) {
-          const hasExport = path2.node.body.some(
+        exit(path3) {
+          const hasExport = path3.node.body.some(
             (node) => node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration"
           );
           if (!hasExport) {
@@ -326,7 +165,7 @@ export const mastra = new Mastra({
               t.variableDeclaration("const", [t.variableDeclarator(t.identifier(option), t.objectExpression([]))]),
               []
             );
-            path2.node.body.push(fallbackExportDeclaration);
+            path3.node.body.push(fallbackExportDeclaration);
           }
         }
       }
@@ -338,14 +177,92 @@ export const mastra = new Mastra({
 function removeAllOptionsExceptBundler(result, logger) {
   return removeAllOptionsFromMastraExcept(result, "bundler", logger);
 }
+function esbuild(options = {}) {
+  return originalEsbuild__default.default({
+    target: "node20",
+    platform: "node",
+    minify: false,
+    ...options
+  });
+}
+var PLUGIN_NAME = "tsconfig-paths";
+function tsConfigPaths({ tsConfigPath, respectCoreModule, localResolve } = {}) {
+  let handler;
+  return {
+    name: PLUGIN_NAME,
+    buildStart() {
+      handler = typescriptPaths.createHandler({
+        log: () => {
+        },
+        tsConfigPath,
+        respectCoreModule,
+        falllback: (moduleName) => fs__default.default.existsSync(moduleName)
+      });
+      return;
+    },
+    async resolveId(request, importer, options) {
+      if (!importer || request.startsWith("\0")) {
+        return null;
+      }
+      const moduleName = handler?.(request, path2.normalize(importer));
+      if (!moduleName) {
+        let importerMeta = {};
+        const resolved = await this.resolve(request, importer, { skipSelf: true, ...options });
+        if (!resolved) {
+          return null;
+        }
+        if (localResolve) {
+          const importerInfo = this.getModuleInfo(importer);
+          importerMeta = importerInfo?.meta || {};
+          if (!request.startsWith("./") && !request.startsWith("../") && importerMeta?.[PLUGIN_NAME]?.resolved) {
+            return {
+              ...resolved,
+              external: !request.startsWith("hono/") && request !== "hono"
+            };
+          }
+        }
+        return {
+          ...resolved,
+          meta: {
+            ...resolved.meta || {},
+            ...importerMeta
+          }
+        };
+      }
+      if (!path2__namespace.default.extname(moduleName)) {
+        const resolved = await this.resolve(moduleName, importer, { skipSelf: true, ...options });
+        if (!resolved) {
+          return null;
+        }
+        return {
+          ...resolved,
+          meta: {
+            ...resolved.meta,
+            [PLUGIN_NAME]: {
+              resolved: true
+            }
+          }
+        };
+      }
+      return {
+        id: moduleName,
+        meta: {
+          [PLUGIN_NAME]: {
+            resolved: true
+          }
+        }
+      };
+    }
+  };
+}
 function removeNonReferencedNodes() {
   const t = babel__namespace.default.types;
   return {
     name: "remove-non-referenced-nodes",
     visitor: {
-      Program(path2) {
-        const scope = path2.scope;
-        const currentBody = path2.get("body");
+      Program(path3) {
+        const scope = path3.scope;
+        const currentBody = path3.get("body");
         const filteredBody = currentBody.filter((childPath) => {
           if (childPath.isExportDeclaration()) {
             return true;
@@ -377,7 +294,7 @@ function removeNonReferencedNodes() {
           }
           return false;
         });
-        path2.set(
+        path3.set(
           "body",
           filteredBody.map((p) => p.node)
         );
@@ -423,13 +340,13 @@ function extractMastraOptionBundler(name, entryFile, transformer, result, logger
       // transpile typescript to something we understand
       esbuild(),
       rollupPlugin.optimizeLodashImports(),
-      commonjs2__default.default({
+      commonjs__default.default({
         extensions: [".js", ".ts"],
         strictRequires: "strict",
         transformMixedEsModules: true,
         ignoreTryCatch: false
       }),
-      json2__default.default(),
+      json__default.default(),
       {
         name: `extract-${name}-config`,
         transform(code, id) {
@@ -513,16 +430,16 @@ function checkConfigExport(result) {
   const mastraVars = /* @__PURE__ */ new Set();
   return {
     visitor: {
-      ExportNamedDeclaration(path2) {
-        const decl = path2.node.declaration;
+      ExportNamedDeclaration(path3) {
+        const decl = path3.node.declaration;
         if (t.isVariableDeclaration(decl)) {
           const varDecl = decl.declarations[0];
           if (t.isIdentifier(varDecl?.id, { name: "mastra" }) && t.isNewExpression(varDecl.init) && t.isIdentifier(varDecl.init.callee, { name: "Mastra" })) {
             result.hasValidConfig = true;
           }
         }
-        if (Array.isArray(path2.node.specifiers)) {
-          for (const spec of path2.node.specifiers) {
+        if (Array.isArray(path3.node.specifiers)) {
+          for (const spec of path3.node.specifiers) {
             if (t.isExportSpecifier(spec) && t.isIdentifier(spec.exported, { name: "mastra" }) && t.isIdentifier(spec.local) && mastraVars.has(spec.local.name)) {
               result.hasValidConfig = true;
             }
@@ -530,8 +447,8 @@ function checkConfigExport(result) {
         }
       },
       // For cases 2-4 we need to track whether those variables are assigned to `new Mastra()`
-      VariableDeclaration(path2) {
-        for (const decl of path2.node.declarations) {
+      VariableDeclaration(path3) {
+        for (const decl of path3.node.declarations) {
           if (t.isIdentifier(decl.id) && t.isNewExpression(decl.init) && t.isIdentifier(decl.init.callee, { name: "Mastra" })) {
             mastraVars.add(decl.id.name);
           }
@@ -540,29 +457,15 @@ function checkConfigExport(result) {
     }
   };
 }
-function getPackageName(id) {
-  const parts = id.split("/");
-  if (id.startsWith("@")) {
-    return parts.slice(0, 2).join("/");
-  }
-  return parts[0];
-}
-async function getPackageRootPath(packageName) {
-  let rootPath;
-  try {
-    const pkg = await localPkg.getPackageInfo(packageName);
-    rootPath = pkg?.rootPath ?? null;
-  } catch (e) {
-    rootPath = null;
-  }
-  return rootPath;
-}
-function getCompiledDepCachePath(rootPath, packageName) {
-  return path.join(rootPath, "node_modules", ".cache", packageName);
-}
-var createWorkspacePackageMap = async () => {
-  const workspaces = await findWorkspaces.findWorkspaces();
-  const workspaceMap = new Map(
+var workspacesCache = findWorkspaces.createWorkspacesCache();
+async function getWorkspaceInformation({
+  dir = process.cwd(),
+  mastraEntryFile
+}) {
+  const closestPkgJson = pkg__namespace.up({ cwd: path2.dirname(mastraEntryFile) });
+  const location = closestPkgJson ? path2.dirname(closestPkgJson) : process.cwd();
+  const workspaces = await findWorkspaces.findWorkspaces(dir, { cache: workspacesCache });
+  const _workspaceMap = new Map(
     workspaces?.map((workspace) => [
       workspace.package.name,
       {
@@ -572,8 +475,15 @@ var createWorkspacePackageMap = async () => {
       }
     ]) ?? []
   );
-  return workspaceMap;
-};
+  const isWorkspacePackage = (workspaces ?? []).some((ws) => ws.location === location);
+  const workspaceRoot = isWorkspacePackage ? findWorkspaces.findWorkspacesRoot(dir, { cache: workspacesCache })?.location : void 0;
+  return {
+    // If the current package is not part of the workspace, the bundling down the line shouldn't look at any workspace packages
+    workspaceMap: isWorkspacePackage ? _workspaceMap : /* @__PURE__ */ new Map(),
+    workspaceRoot,
+    isWorkspacePackage
+  };
+}
 var collectTransitiveWorkspaceDependencies = ({
   workspaceMap,
   initialDependencies,
@@ -626,7 +536,7 @@ var packWorkspaceDependencies = async ({
   const depsService = new chunkHR2HOA5D_cjs.DepsService(root.location);
   depsService.__setLogger(logger);
   if (usedWorkspacePackages.size > 0) {
-    const workspaceDirPath = path.join(bundleOutputDir, "workspace-module");
+    const workspaceDirPath = path2.join(bundleOutputDir, "workspace-module");
     await fsExtra.ensureDir(workspaceDirPath);
     logger.info(`Packaging ${usedWorkspacePackages.size} workspace dependencies...`);
     const batchSize = 5;
@@ -648,44 +558,112 @@ var packWorkspaceDependencies = async ({
     logger.info(`Successfully packaged ${usedWorkspacePackages.size} workspace dependencies`);
   }
 };
-
-// src/build/analyze.ts
-var globalExternals = [
-  "pino",
-  "pino-pretty",
-  "@libsql/client",
-  "pg",
-  "libsql",
-  "jsdom",
-  "sqlite3",
-  "fastembed",
-  "nodemailer",
-  "#tools"
-];
-function findExternalImporter(module, external, allOutputs) {
-  const capturedFiles = /* @__PURE__ */ new Set();
-  for (const id of module.imports) {
-    if (id === external) {
-      return module;
-    } else {
-      if (id.endsWith(".mjs")) {
-        capturedFiles.add(id);
+function isNodeBuiltin(dep) {
+  const [pkg2] = dep.split("/");
+  return dep.startsWith("node:") || module$1.builtinModules.includes(dep) || module$1.builtinModules.includes(pkg2);
+}
+function removeDeployer() {
+  const t = babel__namespace.default.types;
+  return {
+    name: "remove-deployer",
+    visitor: {
+      NewExpression(path3, state) {
+        const varDeclaratorPath = path3.findParent((path4) => t.isVariableDeclarator(path4.node));
+        if (!varDeclaratorPath) {
+          return;
+        }
+        const parentNode = path3.parentPath.node;
+        if (!t.isVariableDeclarator(parentNode) || !t.isIdentifier(parentNode.id) || parentNode.id.name !== "mastra") {
+          return;
+        }
+        if (!state.hasReplaced) {
+          state.hasReplaced = true;
+          const newMastraObj = t.cloneNode(path3.node);
+          if (t.isObjectExpression(newMastraObj.arguments[0]) && newMastraObj.arguments[0].properties?.[0]) {
+            const deployer = newMastraObj.arguments[0].properties.find(
+              (prop) => t.isObjectProperty(prop) && t.isIdentifier(prop.key) && prop.key.name === "deployer"
+            );
+            if (!deployer) {
+              return;
+            }
+            newMastraObj.arguments[0].properties = newMastraObj.arguments[0].properties.filter(
+              (prop) => prop !== deployer
+            );
+            if (t.isObjectProperty(deployer) && t.isIdentifier(deployer.value)) {
+              const deployerBinding = state.file.scope.getBinding(deployer.value.name);
+              if (deployerBinding) {
+                deployerBinding?.path?.parentPath?.remove();
+              }
+            }
+            path3.replaceWith(newMastraObj);
+          }
+        }
       }
     }
-  }
-  for (const file of capturedFiles) {
-    const nextModule = allOutputs.find((o) => o.fileName === file);
-    if (nextModule) {
-      const importer = findExternalImporter(nextModule, external, allOutputs);
-      if (importer) {
-        return importer;
+  };
+}
+
+// src/build/plugins/remove-deployer.ts
+function removeDeployer2(mastraEntry, options) {
+  return {
+    name: "remove-deployer",
+    transform(code, id) {
+      if (id !== mastraEntry) {
+        return;
       }
+      return new Promise((resolve, reject) => {
+        babel__namespace.transform(
+          code,
+          {
+            babelrc: false,
+            configFile: false,
+            filename: id,
+            plugins: [removeDeployer],
+            sourceMaps: options?.sourcemap
+          },
+          (err, result) => {
+            if (err) {
+              return reject(err);
+            }
+            resolve({
+              code: result.code,
+              map: result.map
+            });
+          }
+        );
+      });
     }
+  };
+}
+function getPackageName(id) {
+  const parts = id.split("/");
+  if (id.startsWith("@")) {
+    return parts.slice(0, 2).join("/");
   }
-  return null;
+  return parts[0];
 }
-async function analyze(entry, mastraEntry, isVirtualFile, platform, logger, sourcemapEnabled = false, workspaceMap) {
-  logger.info("Analyzing dependencies...");
+async function getPackageRootPath(packageName) {
+  let rootPath;
+  try {
+    const pkg2 = await localPkg.getPackageInfo(packageName);
+    rootPath = pkg2?.rootPath ?? null;
+  } catch (e) {
+    rootPath = null;
+  }
+  return rootPath;
+}
+function getCompiledDepCachePath(rootPath, packageName) {
+  return path2.join(rootPath, "node_modules", ".cache", packageName);
+}
+
+// src/build/analyze/constants.ts
+var DEPS_TO_IGNORE = ["#tools"];
+var GLOBAL_EXTERNALS = ["pino", "pino-pretty", "@libsql/client", "pg", "libsql", "#tools"];
+var DEPRECATED_EXTERNALS = ["fastembed", "nodemailer", "jsdom", "sqlite3"];
+
+// src/build/analyze/analyzeEntry.ts
+function getInputPlugins({ entry, isVirtualFile }, mastraEntry, { sourcemapEnabled }) {
+  const normalizedMastraEntry = mastraEntry.replaceAll("\\", "/");
   let virtualPlugin = null;
   if (isVirtualFile) {
     virtualPlugin = virtual__default.default({
@@ -693,14 +671,12 @@ async function analyze(entry, mastraEntry, isVirtualFile, platform, logger, sour
     });
     entry = "#entry";
   }
-  const normalizedMastraEntry = mastraEntry.replaceAll("\\", "/");
-  const optimizerBundler = await rollup.rollup({
-    logLevel: process.env.MASTRA_BUNDLER_DEBUG === "true" ? "debug" : "silent",
-    input: isVirtualFile ? "#entry" : entry,
-    treeshake: "smallest",
-    preserveSymlinks: true,
-    plugins: [
-      virtualPlugin,
+  const plugins = [];
+  if (virtualPlugin) {
+    plugins.push(virtualPlugin);
+  }
+  plugins.push(
+    ...[
       tsConfigPaths(),
       {
         name: "custom-alias-resolver",
@@ -714,52 +690,83 @@ async function analyze(entry, mastraEntry, isVirtualFile, platform, logger, sour
           if (id.startsWith("@mastra/server")) {
             return url.fileURLToPath(undefined(id));
           }
-          if (id === "#tools") {
-            return {
-              id: "#tools",
-              external: true
-            };
-          }
         }
       },
-      json2__default.default(),
+      json__default.default(),
       esbuild(),
-      commonjs2__default.default({
+      commonjs__default.default({
         strictRequires: "debug",
         ignoreTryCatch: false,
         transformMixedEsModules: true,
         extensions: [".js", ".ts"]
       }),
-      removeDeployer2(normalizedMastraEntry, { sourcemap: sourcemapEnabled }),
+      removeDeployer2(mastraEntry, { sourcemap: sourcemapEnabled }),
       esbuild()
-    ].filter(Boolean)
-  });
-  const { output } = await optimizerBundler.generate({
-    format: "esm",
-    inlineDynamicImports: true
-  });
-  await optimizerBundler.close();
+    ]
+  );
+  return plugins;
+}
+async function captureDependenciesToOptimize(output, workspaceMap, projectRoot, {
+  logger: logger$1
+}) {
   const depsToOptimize = /* @__PURE__ */ new Map();
-  for (const [dep, bindings] of Object.entries(output[0].importedBindings)) {
-    if (isNodeBuiltin(dep)) {
+  for (const [dependency, bindings] of Object.entries(output.importedBindings)) {
+    if (isNodeBuiltin(dependency) || DEPS_TO_IGNORE.includes(dependency)) {
       continue;
     }
-    const isWorkspace = workspaceMap.has(dep);
-    const pkgName = getPackageName(dep);
+    const pkgName = getPackageName(dependency);
     let rootPath = null;
-    if (pkgName && pkgName !== "#tools") {
+    let isWorkspace = false;
+    if (pkgName) {
       rootPath = await getPackageRootPath(pkgName);
+      isWorkspace = workspaceMap.has(pkgName);
     }
-    depsToOptimize.set(dep, { exports: bindings, rootPath, isWorkspace });
+    depsToOptimize.set(dependency, { exports: bindings, rootPath, isWorkspace });
   }
-  for (const o of output) {
-    if (o.type !== "chunk") {
-      continue;
+  async function checkTransitiveDependencies(internalMap, maxDepth = 10, currentDepth = 0) {
+    if (currentDepth >= maxDepth) {
+      logger$1.warn("Maximum dependency depth reached while checking transitive dependencies.");
+      return;
     }
-    const dynamicImports = o.dynamicImports.filter((d) => d !== "#tools");
-    if (!dynamicImports.length) {
-      continue;
+    const depsSnapshot = new Map(depsToOptimize);
+    let hasAddedDeps = false;
+    for (const [dep, meta] of depsSnapshot) {
+      if (!meta.isWorkspace || internalMap.has(dep)) {
+        continue;
+      }
+      try {
+        const resolvedPath = resolveFrom2__default.default(projectRoot, dep);
+        if (!resolvedPath) {
+          logger$1.warn(`Could not resolve path for workspace dependency ${dep}`);
+          continue;
+        }
+        const analysis = await analyzeEntry({ entry: resolvedPath, isVirtualFile: false }, "", {
+          workspaceMap,
+          projectRoot,
+          logger: logger.noopLogger,
+          sourcemapEnabled: false
+        });
+        if (!analysis?.dependencies) {
+          continue;
+        }
+        for (const [innerDep, innerMeta] of analysis.dependencies) {
+          if (innerMeta.isWorkspace && !internalMap.has(innerDep) && !depsToOptimize.has(innerDep)) {
+            depsToOptimize.set(innerDep, innerMeta);
+            internalMap.set(innerDep, innerMeta);
+            hasAddedDeps = true;
+          }
+        }
+      } catch (err) {
+        logger$1.error(`Failed to resolve or analyze dependency ${dep}: ${err.message}`);
+      }
+    }
+    if (hasAddedDeps) {
+      await checkTransitiveDependencies(internalMap, maxDepth, currentDepth + 1);
     }
+  }
+  await checkTransitiveDependencies(/* @__PURE__ */ new Map());
+  const dynamicImports = output.dynamicImports.filter((d) => !DEPS_TO_IGNORE.includes(d));
+  if (dynamicImports.length) {
     for (const dynamicImport of dynamicImports) {
       if (!depsToOptimize.has(dynamicImport) && !isNodeBuiltin(dynamicImport)) {
         depsToOptimize.set(dynamicImport, { exports: ["*"], rootPath: null, isWorkspace: false });
@@ -768,49 +775,159 @@ async function analyze(entry, mastraEntry, isVirtualFile, platform, logger, sour
   }
   return depsToOptimize;
 }
-async function bundleExternals(depsToOptimize, outputDir, logger, bundlerOptions, meta) {
-  logger.info("Optimizing dependencies...");
-  logger.debug(
-    `${Array.from(depsToOptimize.keys()).map((key) => `- ${key}`).join("\n")}`
-  );
-  const { externals: customExternals = [], transpilePackages = [], isDev = false } = bundlerOptions || {};
-  const { workspaceRoot = null, workspaceMap = /* @__PURE__ */ new Map() } = meta || {};
-  const allExternals = [...globalExternals, ...customExternals];
-  const reverseVirtualReferenceMap = /* @__PURE__ */ new Map();
-  const virtualDependencies = /* @__PURE__ */ new Map();
-  for (const [dep, { exports, isWorkspace, rootPath }] of depsToOptimize.entries()) {
-    let name = dep.replaceAll("/", "-");
-    if (isWorkspace && rootPath && isDev && workspaceRoot) {
-      const absolutePath = getCompiledDepCachePath(rootPath, name);
-      name = absolutePath.replace(workspaceRoot, "").replace(/^[/\\]+/, "");
-    }
-    reverseVirtualReferenceMap.set(name, dep);
+async function analyzeEntry({
+  entry,
+  isVirtualFile
+}, mastraEntry, {
+  logger,
+  sourcemapEnabled,
+  workspaceMap,
+  projectRoot
+}) {
+  const optimizerBundler = await rollup.rollup({
+    logLevel: process.env.MASTRA_BUNDLER_DEBUG === "true" ? "debug" : "silent",
+    input: isVirtualFile ? "#entry" : entry,
+    treeshake: "smallest",
+    preserveSymlinks: true,
+    plugins: getInputPlugins({ entry, isVirtualFile }, mastraEntry, { sourcemapEnabled }),
+    external: DEPS_TO_IGNORE
+  });
+  const { output } = await optimizerBundler.generate({
+    format: "esm",
+    inlineDynamicImports: true
+  });
+  await optimizerBundler.close();
+  const depsToOptimize = await captureDependenciesToOptimize(output[0], workspaceMap, projectRoot, {
+    logger
+  });
+  return {
+    dependencies: depsToOptimize,
+    output: {
+      code: output[0].code,
+      map: output[0].map
+    }
+  };
+}
+function aliasHono() {
+  return {
+    name: "hono-alias",
+    resolveId(id) {
+      if (!id.startsWith("@hono/") && !id.startsWith("hono/") && id !== "hono" && id !== "hono-openapi") {
+        return;
+      }
+      const path3 = undefined(id);
+      return url.fileURLToPath(path3);
+    }
+  };
+}
+
+// src/build/analyze/bundleExternals.ts
+function prepareEntryFileName(name, rootDir) {
+  const relativePath = path2__namespace.relative(rootDir, name);
+  return relativePath.replaceAll(path2__namespace.sep, path2__namespace.posix.sep);
+}
+function createVirtualDependencies(depsToOptimize, { projectRoot, workspaceRoot, outputDir }) {
+  const fileNameToDependencyMap = /* @__PURE__ */ new Map();
+  const optimizedDependencyEntries = /* @__PURE__ */ new Map();
+  const rootDir = workspaceRoot || projectRoot;
+  for (const [dep, { exports }] of depsToOptimize.entries()) {
+    const fileName = dep.replaceAll("/", "-");
     const virtualFile = [];
-    let exportStringBuilder = [];
+    const exportStringBuilder = [];
     for (const local of exports) {
       if (local === "*") {
         virtualFile.push(`export * from '${dep}';`);
+        continue;
       } else if (local === "default") {
-        virtualFile.push(`export { default } from '${dep}';`);
+        exportStringBuilder.push("default");
       } else {
         exportStringBuilder.push(local);
       }
     }
-    if (exportStringBuilder.length > 0) {
-      virtualFile.push(`export { ${exportStringBuilder.join(", ")} } from '${dep}';`);
+    const chunks = [];
+    if (exportStringBuilder.length) {
+      chunks.push(`{ ${exportStringBuilder.join(", ")} }`);
+    }
+    if (chunks.length) {
+      virtualFile.push(`export ${chunks.join(", ")} from '${dep}';`);
     }
-    virtualDependencies.set(dep, {
-      name,
+    let entryName = prepareEntryFileName(path2__namespace.join(outputDir, fileName), rootDir);
+    fileNameToDependencyMap.set(entryName, dep);
+    optimizedDependencyEntries.set(dep, {
+      name: entryName,
       virtual: virtualFile.join("\n")
     });
   }
+  for (const [dep, { isWorkspace, rootPath }] of depsToOptimize.entries()) {
+    if (!isWorkspace || !rootPath || !workspaceRoot) {
+      continue;
+    }
+    const currentDepPath = optimizedDependencyEntries.get(dep);
+    if (!currentDepPath) {
+      continue;
+    }
+    const fileName = posix.basename(currentDepPath.name);
+    const entryName = prepareEntryFileName(getCompiledDepCachePath(rootPath, fileName), rootDir);
+    fileNameToDependencyMap.set(entryName, dep);
+    optimizedDependencyEntries.set(dep, {
+      ...currentDepPath,
+      name: entryName
+    });
+  }
+  return { optimizedDependencyEntries, fileNameToDependencyMap };
+}
+async function getInputPlugins2(virtualDependencies, transpilePackages, workspaceMap, bundlerOptions) {
   const transpilePackagesMap = /* @__PURE__ */ new Map();
-  for (const pkg of transpilePackages) {
-    const dir = await getPackageRootPath(pkg);
+  for (const pkg2 of transpilePackages) {
+    const dir = await getPackageRootPath(pkg2);
     if (dir) {
-      transpilePackagesMap.set(pkg, dir);
+      transpilePackagesMap.set(pkg2, dir);
     }
   }
+  return [
+    virtual__default.default(
+      Array.from(virtualDependencies.entries()).reduce(
+        (acc, [dep, virtualDep]) => {
+          acc[`#virtual-${dep}`] = virtualDep.virtual;
+          return acc;
+        },
+        {}
+      )
+    ),
+    transpilePackagesMap.size ? esbuild({
+      format: "esm",
+      include: [...transpilePackagesMap.values()].map((p) => {
+        return new RegExp(`^${p.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}/(?!.*node_modules).*$`);
+      })
+    }) : null,
+    commonjs__default.default({
+      strictRequires: "strict",
+      transformMixedEsModules: true,
+      ignoreTryCatch: false
+    }),
+    bundlerOptions.enableEsmShim ? esmShim__default.default() : void 0,
+    nodeResolve__default.default({
+      preferBuiltins: true,
+      exportConditions: ["node"],
+      // Do not embed external dependencies into files that we write to `node_modules/.cache` (for the mastra dev + workspace use case)
+      ...workspaceMap.size > 0 ? { resolveOnly: Array.from(workspaceMap.keys()) } : {}
+    }),
+    // hono is imported from deployer, so we need to resolve from here instead of the project root
+    aliasHono(),
+    json__default.default()
+  ];
+}
+async function buildExternalDependencies(virtualDependencies, {
+  externals,
+  packagesToTranspile,
+  workspaceMap,
+  rootDir,
+  outputDir,
+  bundlerOptions
+}) {
+  if (virtualDependencies.size === 0) {
+    return [];
+  }
   const bundler = await rollup.rollup({
     logLevel: process.env.MASTRA_BUNDLER_DEBUG === "true" ? "debug" : "silent",
     input: Array.from(virtualDependencies.entries()).reduce(
@@ -820,81 +937,115 @@ async function bundleExternals(depsToOptimize, outputDir, logger, bundlerOptions
       },
       {}
     ),
-    external: allExternals,
+    external: externals,
     treeshake: "smallest",
-    plugins: [
-      virtual__default.default(
-        Array.from(virtualDependencies.entries()).reduce(
-          (acc, [dep, virtualDep]) => {
-            acc[`#virtual-${dep}`] = virtualDep.virtual;
-            return acc;
-          },
-          {}
-        )
-      ),
-      transpilePackagesMap.size ? esbuild({
-        format: "esm",
-        include: [...transpilePackagesMap.values()].map((p) => {
-          return new RegExp(`^${p.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}/(?!.*node_modules).*$`);
-        })
-      }) : null,
-      commonjs2__default.default({
-        strictRequires: "strict",
-        transformMixedEsModules: true,
-        ignoreTryCatch: false
-      }),
-      isDev ? esmShim__default.default() : void 0,
-      nodeResolve__default.default({
-        preferBuiltins: true,
-        exportConditions: ["node"],
-        // Do not embed external dependencies into files that we write to `node_modules/.cache` (for the mastra dev + workspace use case)
-        ...workspaceMap.size > 0 && isDev ? { resolveOnly: Array.from(workspaceMap.keys()) } : {}
-      }),
-      // hono is imported from deployer, so we need to resolve from here instead of the project root
-      aliasHono(),
-      json2__default.default()
-    ].filter(Boolean)
+    plugins: getInputPlugins2(virtualDependencies, packagesToTranspile, workspaceMap, bundlerOptions)
   });
+  const outputDirRelative = prepareEntryFileName(outputDir, rootDir);
   const { output } = await bundler.write({
     format: "esm",
+    dir: rootDir,
+    entryFileNames: "[name].mjs",
     /**
-     * If Mastra is used inside a monorepo, we need to find the workspace root so that Rollup can use it as base for the output dir. This should only happen during `mastra dev`.
-     *
-     * Otherwise, use outputDir as normal.
+     * Rollup creates chunks for common dependencies, but these chunks are by default written to the root directory instead of respecting the entryFileNames structure.
+     * So we want to write them to the `.mastra/output` folder as well.
      */
-    dir: isDev ? workspaceRoot ? workspaceRoot : outputDir : outputDir,
-    entryFileNames: "[name].mjs",
-    chunkFileNames: "[name].mjs",
+    chunkFileNames: `${outputDirRelative}/[name].mjs`,
     hoistTransitiveImports: false
   });
-  const moduleResolveMap = {};
+  await bundler.close();
+  return output;
+}
+function findExternalImporter(module, external, allOutputs) {
+  const capturedFiles = /* @__PURE__ */ new Set();
+  for (const id of module.imports) {
+    if (id === external) {
+      return module;
+    } else {
+      if (id.endsWith(".mjs")) {
+        capturedFiles.add(id);
+      }
+    }
+  }
+  for (const file of capturedFiles) {
+    const nextModule = allOutputs.find((o) => o.fileName === file);
+    if (nextModule) {
+      const importer = findExternalImporter(nextModule, external, allOutputs);
+      if (importer) {
+        return importer;
+      }
+    }
+  }
+  return null;
+}
+async function bundleExternals(depsToOptimize, outputDir, options) {
+  const { workspaceRoot = null, workspaceMap = /* @__PURE__ */ new Map(), projectRoot = outputDir, bundlerOptions = {} } = options;
+  const {
+    externals: customExternals = [],
+    transpilePackages = [],
+    isDev = false,
+    enableEsmShim = true
+  } = bundlerOptions || {};
+  const allExternals = [...GLOBAL_EXTERNALS, ...DEPRECATED_EXTERNALS, ...customExternals];
+  const workspacePackagesNames = Array.from(workspaceMap.keys());
+  const packagesToTranspile = /* @__PURE__ */ new Set([...transpilePackages, ...workspacePackagesNames]);
+  const { optimizedDependencyEntries, fileNameToDependencyMap } = createVirtualDependencies(depsToOptimize, {
+    workspaceRoot,
+    outputDir,
+    projectRoot
+  });
+  const output = await buildExternalDependencies(optimizedDependencyEntries, {
+    externals: allExternals,
+    packagesToTranspile,
+    workspaceMap: isDev ? workspaceMap : /* @__PURE__ */ new Map(),
+    rootDir: workspaceRoot || projectRoot,
+    outputDir,
+    bundlerOptions: {
+      enableEsmShim
+    }
+  });
+  const moduleResolveMap = /* @__PURE__ */ new Map();
   const filteredChunks = output.filter((o) => o.type === "chunk");
   for (const o of filteredChunks.filter((o2) => o2.isEntry || o2.isDynamicEntry)) {
     for (const external of allExternals) {
-      if (external === "#tools") {
+      if (DEPS_TO_IGNORE.includes(external)) {
         continue;
       }
       const importer = findExternalImporter(o, external, filteredChunks);
       if (importer) {
-        const fullPath = path.join(outputDir, importer.fileName);
-        moduleResolveMap[fullPath] = moduleResolveMap[fullPath] || {};
+        const fullPath = path2__namespace.join(workspaceRoot || projectRoot, importer.fileName);
+        let innerMap = moduleResolveMap.get(fullPath);
+        if (!innerMap) {
+          innerMap = /* @__PURE__ */ new Map();
+          moduleResolveMap.set(fullPath, innerMap);
+        }
         if (importer.moduleIds.length) {
-          moduleResolveMap[fullPath][external] = importer.moduleIds[importer.moduleIds.length - 1]?.startsWith(
-            "\0virtual:#virtual"
-          ) ? importer.moduleIds[importer.moduleIds.length - 2] : importer.moduleIds[importer.moduleIds.length - 1];
+          innerMap.set(
+            external,
+            importer.moduleIds[importer.moduleIds.length - 1]?.startsWith("\0virtual:#virtual") ? importer.moduleIds[importer.moduleIds.length - 2] : importer.moduleIds[importer.moduleIds.length - 1]
+          );
         }
       }
     }
   }
-  await promises.writeFile(path.join(outputDir, "module-resolve-map.json"), JSON.stringify(moduleResolveMap, null, 2));
-  await bundler.close();
-  return { output, reverseVirtualReferenceMap, usedExternals: moduleResolveMap };
+  const usedExternals = /* @__PURE__ */ Object.create(null);
+  for (const [fullPath, innerMap] of moduleResolveMap) {
+    const innerObj = /* @__PURE__ */ Object.create(null);
+    for (const [external, value] of innerMap) {
+      innerObj[external] = value;
+    }
+    usedExternals[fullPath] = innerObj;
+  }
+  return { output, fileNameToDependencyMap, usedExternals };
 }
+
+// src/build/analyze.ts
 async function validateOutput({
   output,
   reverseVirtualReferenceMap,
   usedExternals,
   outputDir,
+  projectRoot,
   workspaceMap
 }, logger) {
   const result = {
@@ -903,6 +1054,7 @@ async function validateOutput({
     externalDependencies: /* @__PURE__ */ new Set(),
     workspaceMap
   };
+  await promises.writeFile(path2.join(outputDir, "module-resolve-map.json"), JSON.stringify(usedExternals, null, 2));
   for (const deps of Object.values(usedExternals)) {
     for (const dep of Object.keys(deps)) {
       result.externalDependencies.add(dep);
@@ -918,7 +1070,7 @@ async function validateOutput({
         result.dependencies.set(reverseVirtualReferenceMap.get(file.name), file.fileName);
       }
       if (!file.isDynamicEntry && file.isEntry) {
-        await validate(path.join(outputDir, file.fileName));
+        await validate(path2.join(projectRoot, file.fileName));
       }
     } catch (err) {
       result.invalidChunks.add(file.fileName);
@@ -931,7 +1083,12 @@ async function validateOutput({
   }
   return result;
 }
-async function analyzeBundle(entries, mastraEntry, outputDir, platform, logger, sourcemapEnabled = false) {
+async function analyzeBundle(entries, mastraEntry, {
+  outputDir,
+  projectRoot,
+  isDev = false,
+  bundlerOptions: _bundlerOptions
+}, logger) {
   const mastraConfig = await promises.readFile(mastraEntry, "utf-8");
   const mastraConfigResult = {
     hasValidConfig: false
@@ -949,46 +1106,64 @@ export const mastra = new Mastra({
   
 If you think your configuration is valid, please open an issue.`);
   }
-  const workspaceMap = await createWorkspacePackageMap();
+  const { enableEsmShim = true } = _bundlerOptions || {};
+  const bundlerOptions = await getBundlerOptions(mastraEntry, outputDir);
+  const { workspaceMap, workspaceRoot } = await getWorkspaceInformation({ mastraEntryFile: mastraEntry });
+  let index = 0;
   const depsToOptimize = /* @__PURE__ */ new Map();
+  logger.info("Analyzing dependencies...");
   for (const entry of entries) {
     const isVirtualFile = entry.includes("\n") || !fs.existsSync(entry);
-    const analyzeResult = await analyze(
-      entry,
-      mastraEntry,
-      isVirtualFile,
-      platform,
+    const analyzeResult = await analyzeEntry({ entry, isVirtualFile }, mastraEntry, {
       logger,
-      sourcemapEnabled,
-      workspaceMap
-    );
-    for (const [dep, { exports }] of analyzeResult.entries()) {
+      sourcemapEnabled: bundlerOptions?.sourcemap ?? false,
+      workspaceMap,
+      projectRoot
+    });
+    await promises.writeFile(path2.join(outputDir, `entry-${index++}.mjs`), analyzeResult.output.code);
+    for (const [dep, metadata] of analyzeResult.dependencies.entries()) {
       if (depsToOptimize.has(dep)) {
         const existingEntry = depsToOptimize.get(dep);
         depsToOptimize.set(dep, {
           ...existingEntry,
-          exports: [.../* @__PURE__ */ new Set([...existingEntry.exports, ...exports])]
+          exports: [.../* @__PURE__ */ new Set([...existingEntry.exports, ...metadata.exports])]
         });
       } else {
-        const isWorkspace = workspaceMap.has(dep);
-        const pkgName = getPackageName(dep);
-        let rootPath = null;
-        if (pkgName && pkgName !== "#tools") {
-          rootPath = await getPackageRootPath(pkgName);
-        }
-        depsToOptimize.set(dep, { exports, rootPath, isWorkspace });
+        depsToOptimize.set(dep, metadata);
       }
     }
   }
-  const bundlerOptions = await getBundlerOptions(mastraEntry, outputDir);
-  const { output, reverseVirtualReferenceMap, usedExternals } = await bundleExternals(
-    depsToOptimize,
-    outputDir,
-    logger,
-    bundlerOptions ?? void 0
+  if (isDev) {
+    for (const [dep, metadata] of depsToOptimize.entries()) {
+      if (!metadata.isWorkspace) {
+        depsToOptimize.delete(dep);
+      }
+    }
+  }
+  logger.debug(`Analyzed dependencies: ${Array.from(depsToOptimize.keys()).join(", ")}`);
+  logger.info("Optimizing dependencies...");
+  logger.debug(
+    `${Array.from(depsToOptimize.keys()).map((key) => `- ${key}`).join("\n")}`
   );
+  const { output, fileNameToDependencyMap, usedExternals } = await bundleExternals(depsToOptimize, outputDir, {
+    bundlerOptions: {
+      ...bundlerOptions,
+      enableEsmShim,
+      isDev
+    },
+    projectRoot,
+    workspaceRoot,
+    workspaceMap
+  });
   const result = await validateOutput(
-    { output, reverseVirtualReferenceMap, usedExternals, outputDir, workspaceMap },
+    {
+      output,
+      reverseVirtualReferenceMap: fileNameToDependencyMap,
+      usedExternals,
+      outputDir,
+      projectRoot: workspaceRoot || projectRoot,
+      workspaceMap
+    },
     logger
   );
   return result;
@@ -996,17 +1171,16 @@ If you think your configuration is valid, please open an issue.`);
 
 exports.aliasHono = aliasHono;
 exports.analyzeBundle = analyzeBundle;
-exports.bundleExternals = bundleExternals;
 exports.collectTransitiveWorkspaceDependencies = collectTransitiveWorkspaceDependencies;
-exports.createWorkspacePackageMap = createWorkspacePackageMap;
 exports.esbuild = esbuild;
 exports.extractMastraOption = extractMastraOption;
 exports.getBundlerOptions = getBundlerOptions;
 exports.getPackageName = getPackageName;
 exports.getPackageRootPath = getPackageRootPath;
+exports.getWorkspaceInformation = getWorkspaceInformation;
 exports.packWorkspaceDependencies = packWorkspaceDependencies;
 exports.removeAllOptionsFromMastraExcept = removeAllOptionsFromMastraExcept;
 exports.removeDeployer = removeDeployer2;
 exports.tsConfigPaths = tsConfigPaths;
-//# sourceMappingURL=chunk-T4L3WY7M.cjs.map
-//# sourceMappingURL=chunk-T4L3WY7M.cjs.map
+//# sourceMappingURL=chunk-M54YPGM4.cjs.map
+//# sourceMappingURL=chunk-M54YPGM4.cjs.map