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

package/dist/{chunk-5ZHIZCMJ.js → chunk-YJOKHEUC.js}

@@ -1,123 +1,31 @@
 import { DepsService } from './chunk-YOULDYHE.js';
 import * as babel from '@babel/core';
 import babel__default from '@babel/core';
-import commonjs2 from '@rollup/plugin-commonjs';
-import json2 from '@rollup/plugin-json';
-import nodeResolve from '@rollup/plugin-node-resolve';
-import virtual from '@rollup/plugin-virtual';
-import esmShim from '@rollup/plugin-esm-shim';
 import fs, { existsSync } from 'fs';
-import { writeFile, readFile } from 'fs/promises';
-import { fileURLToPath } from 'url';
+import { readFile, writeFile } from 'fs/promises';
+import * as path2 from 'path';
+import path2__default, { dirname, join, normalize } from 'path';
+import { spawn as spawn$1 } from 'child_process';
 import { rollup } from 'rollup';
 import originalEsbuild from 'rollup-plugin-esbuild';
-import { builtinModules } from 'module';
-import path, { join, normalize, dirname } from 'path';
-import { spawn as spawn$1 } from 'child_process';
+import commonjs from '@rollup/plugin-commonjs';
+import resolveFrom2 from 'resolve-from';
 import { createHandler } from 'typescript-paths';
 import { optimizeLodashImports } from '@optimize-lodash/rollup-plugin';
-import { getPackageInfo } from 'local-pkg';
+import json from '@rollup/plugin-json';
 import slugify from '@sindresorhus/slugify';
-import { findWorkspaces, findWorkspacesRoot } from 'find-workspaces';
+import * as pkg from 'empathic/package';
+import { createWorkspacesCache, findWorkspaces, findWorkspacesRoot } from 'find-workspaces';
 import { ensureDir } from 'fs-extra';
+import { noopLogger } from '@mastra/core/logger';
+import virtual from '@rollup/plugin-virtual';
+import { fileURLToPath } from 'url';
+import { builtinModules } from 'module';
+import { getPackageInfo } from 'local-pkg';
+import nodeResolve from '@rollup/plugin-node-resolve';
+import esmShim from '@rollup/plugin-esm-shim';
+import { basename } from 'path/posix';
 
-function esbuild(options = {}) {
-  return originalEsbuild({
-    target: "node20",
-    platform: "node",
-    minify: false,
-    ...options
-  });
-}
-function isNodeBuiltin(dep) {
-  const [pkg] = dep.split("/");
-  return dep.startsWith("node:") || builtinModules.includes(dep) || 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 = import.meta.resolve(id);
-      return fileURLToPath(path2);
-    }
-  };
-}
-function removeDeployer() {
-  const t = babel__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.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 = spawn$1(command, args, {
@@ -155,76 +63,6 @@ function validate(file) {
     }
   );
 }
-var PLUGIN_NAME = "tsconfig-paths";
-function tsConfigPaths({ tsConfigPath, respectCoreModule, localResolve } = {}) {
-  let handler;
-  return {
-    name: PLUGIN_NAME,
-    buildStart() {
-      handler = createHandler({
-        log: () => {
-        },
-        tsConfigPath,
-        respectCoreModule,
-        falllback: (moduleName) => fs.existsSync(moduleName)
-      });
-      return;
-    },
-    async resolveId(request, importer, options) {
-      if (!importer || request.startsWith("\0")) {
-        return null;
-      }
-      const moduleName = handler?.(request, 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.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__default.types;
   return {
@@ -232,29 +70,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;
         }
@@ -264,7 +102,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;
             }
@@ -277,8 +115,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) {
@@ -294,7 +132,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);
           }
         }
       }
@@ -306,14 +144,92 @@ export const mastra = new Mastra({
 function removeAllOptionsExceptBundler(result, logger) {
   return removeAllOptionsFromMastraExcept(result, "bundler", logger);
 }
+function esbuild(options = {}) {
+  return originalEsbuild({
+    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 = createHandler({
+        log: () => {
+        },
+        tsConfigPath,
+        respectCoreModule,
+        falllback: (moduleName) => fs.existsSync(moduleName)
+      });
+      return;
+    },
+    async resolveId(request, importer, options) {
+      if (!importer || request.startsWith("\0")) {
+        return null;
+      }
+      const moduleName = handler?.(request, 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__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__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;
@@ -345,7 +261,7 @@ function removeNonReferencedNodes() {
           }
           return false;
         });
-        path2.set(
+        path3.set(
           "body",
           filteredBody.map((p) => p.node)
         );
@@ -391,13 +307,13 @@ function extractMastraOptionBundler(name, entryFile, transformer, result, logger
       // transpile typescript to something we understand
       esbuild(),
       optimizeLodashImports(),
-      commonjs2({
+      commonjs({
         extensions: [".js", ".ts"],
         strictRequires: "strict",
         transformMixedEsModules: true,
         ignoreTryCatch: false
       }),
-      json2(),
+      json(),
       {
         name: `extract-${name}-config`,
         transform(code, id) {
@@ -481,16 +397,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;
             }
@@ -498,8 +414,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);
           }
@@ -508,29 +424,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 getPackageInfo(packageName);
-    rootPath = pkg?.rootPath ?? null;
-  } catch (e) {
-    rootPath = null;
-  }
-  return rootPath;
-}
-function getCompiledDepCachePath(rootPath, packageName) {
-  return join(rootPath, "node_modules", ".cache", packageName);
-}
-var createWorkspacePackageMap = async () => {
-  const workspaces = await findWorkspaces();
-  const workspaceMap = new Map(
+var workspacesCache = createWorkspacesCache();
+async function getWorkspaceInformation({
+  dir = process.cwd(),
+  mastraEntryFile
+}) {
+  const closestPkgJson = pkg.up({ cwd: dirname(mastraEntryFile) });
+  const location = closestPkgJson ? dirname(closestPkgJson) : process.cwd();
+  const workspaces = await findWorkspaces(dir, { cache: workspacesCache });
+  const _workspaceMap = new Map(
     workspaces?.map((workspace) => [
       workspace.package.name,
       {
@@ -540,8 +442,15 @@ var createWorkspacePackageMap = async () => {
       }
     ]) ?? []
   );
-  return workspaceMap;
-};
+  const isWorkspacePackage = (workspaces ?? []).some((ws) => ws.location === location);
+  const workspaceRoot = isWorkspacePackage ? 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,
@@ -616,44 +525,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:") || builtinModules.includes(dep) || builtinModules.includes(pkg2);
+}
+function removeDeployer() {
+  const t = babel__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.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 getPackageInfo(packageName);
+    rootPath = pkg2?.rootPath ?? null;
+  } catch (e) {
+    rootPath = null;
+  }
+  return rootPath;
+}
+function getCompiledDepCachePath(rootPath, packageName) {
+  return 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({
@@ -661,14 +638,12 @@ async function analyze(entry, mastraEntry, isVirtualFile, platform, logger, sour
     });
     entry = "#entry";
   }
-  const normalizedMastraEntry = mastraEntry.replaceAll("\\", "/");
-  const optimizerBundler = await 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",
@@ -682,52 +657,83 @@ async function analyze(entry, mastraEntry, isVirtualFile, platform, logger, sour
           if (id.startsWith("@mastra/server")) {
             return fileURLToPath(import.meta.resolve(id));
           }
-          if (id === "#tools") {
-            return {
-              id: "#tools",
-              external: true
-            };
-          }
         }
       },
-      json2(),
+      json(),
       esbuild(),
-      commonjs2({
+      commonjs({
         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
+}) {
   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.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(projectRoot, dep);
+        if (!resolvedPath) {
+          logger.warn(`Could not resolve path for workspace dependency ${dep}`);
+          continue;
+        }
+        const analysis = await analyzeEntry({ entry: resolvedPath, isVirtualFile: false }, "", {
+          workspaceMap,
+          projectRoot,
+          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.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 });
@@ -736,49 +742,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({
+    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 = import.meta.resolve(id);
+      return fileURLToPath(path3);
+    }
+  };
+}
+
+// src/build/analyze/bundleExternals.ts
+function prepareEntryFileName(name, rootDir) {
+  const relativePath = path2.relative(rootDir, name);
+  return relativePath.replaceAll(path2.sep, path2.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.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 = 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(
+      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({
+      strictRequires: "strict",
+      transformMixedEsModules: true,
+      ignoreTryCatch: false
+    }),
+    bundlerOptions.enableEsmShim ? esmShim() : void 0,
+    nodeResolve({
+      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()
+  ];
+}
+async function buildExternalDependencies(virtualDependencies, {
+  externals,
+  packagesToTranspile,
+  workspaceMap,
+  rootDir,
+  outputDir,
+  bundlerOptions
+}) {
+  if (virtualDependencies.size === 0) {
+    return [];
+  }
   const bundler = await rollup({
     logLevel: process.env.MASTRA_BUNDLER_DEBUG === "true" ? "debug" : "silent",
     input: Array.from(virtualDependencies.entries()).reduce(
@@ -788,81 +904,115 @@ async function bundleExternals(depsToOptimize, outputDir, logger, bundlerOptions
       },
       {}
     ),
-    external: allExternals,
+    external: externals,
     treeshake: "smallest",
-    plugins: [
-      virtual(
-        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({
-        strictRequires: "strict",
-        transformMixedEsModules: true,
-        ignoreTryCatch: false
-      }),
-      isDev ? esmShim() : void 0,
-      nodeResolve({
-        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()
-    ].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 = join(outputDir, importer.fileName);
-        moduleResolveMap[fullPath] = moduleResolveMap[fullPath] || {};
+        const fullPath = path2.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 writeFile(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 = {
@@ -871,6 +1021,7 @@ async function validateOutput({
     externalDependencies: /* @__PURE__ */ new Set(),
     workspaceMap
   };
+  await writeFile(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);
@@ -886,7 +1037,7 @@ async function validateOutput({
         result.dependencies.set(reverseVirtualReferenceMap.get(file.name), file.fileName);
       }
       if (!file.isDynamicEntry && file.isEntry) {
-        await validate(join(outputDir, file.fileName));
+        await validate(join(projectRoot, file.fileName));
       }
     } catch (err) {
       result.invalidChunks.add(file.fileName);
@@ -899,7 +1050,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 readFile(mastraEntry, "utf-8");
   const mastraConfigResult = {
     hasValidConfig: false
@@ -917,51 +1073,69 @@ 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") || !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 writeFile(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;
 }
 
-export { aliasHono, analyzeBundle, bundleExternals, collectTransitiveWorkspaceDependencies, createWorkspacePackageMap, esbuild, extractMastraOption, getBundlerOptions, getPackageName, getPackageRootPath, packWorkspaceDependencies, removeAllOptionsFromMastraExcept, removeDeployer2 as removeDeployer, tsConfigPaths };
-//# sourceMappingURL=chunk-5ZHIZCMJ.js.map
-//# sourceMappingURL=chunk-5ZHIZCMJ.js.map
+export { aliasHono, analyzeBundle, collectTransitiveWorkspaceDependencies, esbuild, extractMastraOption, getBundlerOptions, getPackageName, getPackageRootPath, getWorkspaceInformation, packWorkspaceDependencies, removeAllOptionsFromMastraExcept, removeDeployer2 as removeDeployer, tsConfigPaths };
+//# sourceMappingURL=chunk-YJOKHEUC.js.map
+//# sourceMappingURL=chunk-YJOKHEUC.js.map