@mastra/deployer 1.0.0-beta.5 → 1.0.0-beta.7

package/dist/{chunk-NK3AYZ6D.js → chunk-UEFVUIPU.js}

@@ -1,12 +1,11 @@
+import { slash, isDependencyPartOfPackage, getPackageRootPath, getPackageName, getCompiledDepCachePath, rollupSafeName } from './chunk-5CWPEG6R.js';
 import * as babel from '@babel/core';
 import babel__default from '@babel/core';
 import fs, { existsSync } from 'fs';
 import { readFile, writeFile } from 'fs/promises';
 import * as path2 from 'path';
-import path2__default, { dirname, join, normalize, relative, basename as basename$1 } from 'path';
+import path2__default, { dirname, join, normalize, basename as basename$1 } from 'path';
 import { spawn as spawn$1 } from 'child_process';
-import { getPackageInfo } from 'local-pkg';
-import { pathToFileURL, fileURLToPath } from 'url';
 import { rollup } from 'rollup';
 import originalEsbuild from 'rollup-plugin-esbuild';
 import commonjs from '@rollup/plugin-commonjs';
@@ -18,90 +17,27 @@ import * as pkg from 'empathic/package';
 import { createWorkspacesCache, findWorkspaces, findWorkspacesRoot } from 'find-workspaces';
 import { noopLogger } from '@mastra/core/logger';
 import virtual from '@rollup/plugin-virtual';
+import { fileURLToPath, pathToFileURL } from 'url';
 import { builtinModules } from 'module';
 import nodeResolve from '@rollup/plugin-node-resolve';
-import esmShim from '@rollup/plugin-esm-shim';
+import originalEsmShim from '@rollup/plugin-esm-shim';
 import { basename } from 'path/posix';
 import * as resolve from 'resolve.exports';
+import { getPackageInfo } from 'local-pkg';
 import { MastraBaseError, ErrorCategory, ErrorDomain, MastraError } from '@mastra/core/error';
 
-// src/build/analyze.ts
-function getPackageName(id) {
-  const parts = id.split("/");
-  if (id.startsWith("@")) {
-    return parts.slice(0, 2).join("/");
-  }
-  return parts[0];
-}
-async function getPackageRootPath(packageName, parentPath) {
-  let rootPath;
-  try {
-    let options = void 0;
-    if (parentPath) {
-      if (!parentPath.startsWith("file://")) {
-        parentPath = pathToFileURL(parentPath).href;
-      }
-      options = {
-        paths: [parentPath]
-      };
-    }
-    const pkg2 = await getPackageInfo(packageName, options);
-    rootPath = pkg2?.rootPath ?? null;
-  } catch (e) {
-    rootPath = null;
-  }
-  return rootPath;
-}
-function getCompiledDepCachePath(rootPath, packageName) {
-  return slash(join(rootPath, "node_modules", ".cache", packageName));
-}
-function slash(path3) {
-  const isExtendedLengthPath = path3.startsWith("\\\\?\\");
-  if (isExtendedLengthPath) {
-    return path3;
-  }
-  return path3.replaceAll("\\", "/");
-}
-function rollupSafeName(name, rootDir) {
-  const rel = relative(rootDir, name);
-  let entry = slash(rel);
-  entry = entry.replace(/^(\.\.\/)+/, "");
-  entry = entry.replace(/^\/+/, "");
-  entry = entry.replace(/^[A-Za-z]:\//, "");
-  if (!entry) {
-    entry = slash(basename$1(name));
+var ValidationError = class extends Error {
+  type;
+  stack;
+  constructor(args) {
+    super(args.message);
+    this.type = args.type;
+    this.stack = args.stack;
   }
-  return entry;
-}
-var NATIVE_BINDING_LOADERS = [
-  "node-gyp-build",
-  "prebuild-install",
-  "bindings",
-  "node-addon-api",
-  "node-pre-gyp",
-  "nan"
-  // Native Abstractions for Node.js
-];
-function findNativePackageModule(moduleIds) {
-  return moduleIds.find((id) => {
-    if (id.startsWith("\0")) {
-      return false;
-    }
-    if (!id.includes("/node_modules/")) {
-      return false;
-    }
-    for (const loader of NATIVE_BINDING_LOADERS) {
-      if (id.includes(`/${loader}/`) || id.includes(`/${loader}@`)) {
-        return false;
-      }
-    }
-    return true;
-  });
-}
-
-// src/validator/validate.ts
+};
 function spawn(command, args = [], options = {}) {
   return new Promise((resolve2, reject) => {
+    let validationError = null;
     const childProcess = spawn$1(command, args, {
       // stdio: 'inherit',
       ...options
@@ -111,28 +47,63 @@ function spawn(command, args = [], options = {}) {
     });
     let stderr = "";
     childProcess.stderr?.on("data", (message) => {
-      stderr += message;
+      try {
+        validationError = JSON.parse(message.toString());
+      } catch {
+        stderr += message;
+      }
     });
     childProcess.on("close", (code) => {
       if (code === 0) {
         resolve2();
       } else {
-        reject(new Error(stderr));
+        if (validationError) {
+          reject(new ValidationError(validationError));
+        } else {
+          reject(new Error(stderr));
+        }
       }
     });
   });
 }
-function validate(file) {
+function validate(file, { injectESMShim = false, moduleResolveMapLocation }) {
+  let prefixCode = "";
+  if (injectESMShim) {
+    prefixCode = `import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+
+globalThis.__filename = fileURLToPath(import.meta.url);
+globalThis.__dirname = dirname(__filename);
+    `;
+  }
+  function errorHandler(err) {
+    console.error(
+      JSON.stringify({
+        type: err.name,
+        message: err.message,
+        stack: err.stack
+      })
+    );
+    process.exit(1);
+  }
   return spawn(
-    "node",
+    process.execPath,
     [
       "--import",
       import.meta.resolve("@mastra/deployer/loader"),
       "--input-type=module",
+      "--enable-source-maps",
       "-e",
-      `import('file://${slash(file)}')`
+      `${prefixCode};import('file://${slash(file)}').catch(err => {
+        ${errorHandler.toString()}
+        errorHandler(err);
+      })`.replaceAll(/\n/g, "")
     ],
     {
+      env: {
+        ...process.env,
+        MODULE_MAP: `${moduleResolveMapLocation}`
+      },
       cwd: dirname(file)
     }
   );
@@ -228,28 +199,88 @@ function esbuild(options = {}) {
 }
 var PLUGIN_NAME = "tsconfig-paths";
 function tsConfigPaths({ tsConfigPath, respectCoreModule, localResolve } = {}) {
-  let handler;
+  const handlerCache = /* @__PURE__ */ new Map();
+  function findTsConfigForFile(filePath) {
+    let currentDir = path2__default.dirname(filePath);
+    const root = path2__default.parse(currentDir).root;
+    while (currentDir !== root) {
+      const tsConfigPath2 = path2__default.join(currentDir, "tsconfig.json");
+      if (fs.existsSync(tsConfigPath2)) {
+        if (hasPaths(tsConfigPath2)) {
+          return tsConfigPath2;
+        }
+      }
+      const tsConfigBasePath = path2__default.join(currentDir, "tsconfig.base.json");
+      if (fs.existsSync(tsConfigBasePath)) {
+        if (hasPaths(tsConfigBasePath)) {
+          return tsConfigBasePath;
+        }
+      }
+      currentDir = path2__default.dirname(currentDir);
+    }
+    return null;
+  }
+  function hasPaths(tsConfigPath2) {
+    try {
+      const config = JSON.parse(fs.readFileSync(tsConfigPath2, "utf8"));
+      return !!(config.compilerOptions?.paths && Object.keys(config.compilerOptions.paths).length > 0);
+    } catch {
+      return false;
+    }
+  }
+  function getHandlerForFile(filePath) {
+    if (tsConfigPath && typeof tsConfigPath === "string") {
+      if (!handlerCache.has(tsConfigPath)) {
+        handlerCache.set(
+          tsConfigPath,
+          createHandler({
+            log: () => {
+            },
+            tsConfigPath,
+            respectCoreModule,
+            falllback: (moduleName) => fs.existsSync(moduleName)
+          })
+        );
+      }
+      return handlerCache.get(tsConfigPath);
+    }
+    const configPath = findTsConfigForFile(filePath);
+    if (!configPath) {
+      return null;
+    }
+    if (!handlerCache.has(configPath)) {
+      handlerCache.set(
+        configPath,
+        createHandler({
+          log: () => {
+          },
+          tsConfigPath: configPath,
+          respectCoreModule,
+          falllback: (moduleName) => fs.existsSync(moduleName)
+        })
+      );
+    }
+    return handlerCache.get(configPath);
+  }
+  function resolveAlias(request, importer) {
+    const dynamicHandler = getHandlerForFile(importer);
+    if (!dynamicHandler) {
+      return null;
+    }
+    const resolved = dynamicHandler(request, normalize(importer));
+    return resolved;
+  }
   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")) {
+      if (!importer || request.startsWith("\0") || importer.charCodeAt(0) === 0) {
         return null;
       }
-      const moduleName = handler?.(request, normalize(importer));
+      const moduleName = resolveAlias(request, importer);
       if (!moduleName) {
         let importerMeta = {};
-        const resolved = await this.resolve(request, importer, { skipSelf: true, ...options });
-        if (!resolved) {
+        const resolved2 = await this.resolve(request, importer, { skipSelf: true, ...options });
+        if (!resolved2) {
           return null;
         }
         if (localResolve) {
@@ -257,37 +288,42 @@ function tsConfigPaths({ tsConfigPath, respectCoreModule, localResolve } = {}) {
           importerMeta = importerInfo?.meta || {};
           if (!request.startsWith("./") && !request.startsWith("../") && importerMeta?.[PLUGIN_NAME]?.resolved) {
             return {
-              ...resolved,
+              ...resolved2,
               external: !request.startsWith("hono/") && request !== "hono"
             };
           }
         }
         return {
-          ...resolved,
+          ...resolved2,
           meta: {
-            ...resolved.meta || {},
+            ...resolved2.meta || {},
             ...importerMeta
           }
         };
       }
       if (!path2__default.extname(moduleName)) {
-        const resolved = await this.resolve(moduleName, importer, { skipSelf: true, ...options });
-        if (!resolved) {
+        const resolved2 = await this.resolve(moduleName, importer, { skipSelf: true, ...options });
+        if (!resolved2) {
           return null;
         }
         return {
-          ...resolved,
+          ...resolved2,
           meta: {
-            ...resolved.meta,
+            ...resolved2.meta,
             [PLUGIN_NAME]: {
               resolved: true
             }
           }
         };
       }
+      const resolved = await this.resolve(moduleName, importer, { skipSelf: true, ...options });
+      if (!resolved) {
+        return null;
+      }
       return {
-        id: moduleName,
+        ...resolved,
         meta: {
+          ...resolved.meta,
           [PLUGIN_NAME]: {
             resolved: true
           }
@@ -666,7 +702,8 @@ function getInputPlugins({ entry, isVirtualFile }, mastraEntry, { sourcemapEnabl
   return plugins;
 }
 async function captureDependenciesToOptimize(output, workspaceMap, projectRoot, initialDepsToOptimize, {
-  logger
+  logger,
+  shouldCheckTransitiveDependencies
 }) {
   const depsToOptimize = /* @__PURE__ */ new Map();
   if (!output.facadeModuleId) {
@@ -679,7 +716,7 @@ async function captureDependenciesToOptimize(output, workspaceMap, projectRoot,
     entryRootPath = await getPackageRootPath(output.facadeModuleId) || projectRoot;
   }
   for (const [dependency, bindings] of Object.entries(output.importedBindings)) {
-    if (isNodeBuiltin(dependency) || DEPS_TO_IGNORE.includes(dependency)) {
+    if (isNodeBuiltin(dependency) || dependency.startsWith("#")) {
       continue;
     }
     const pkgName = getPackageName(dependency);
@@ -690,7 +727,11 @@ async function captureDependenciesToOptimize(output, workspaceMap, projectRoot,
       isWorkspace = workspaceMap.has(pkgName);
     }
     const normalizedRootPath = rootPath ? slash(rootPath) : null;
-    depsToOptimize.set(dependency, { exports: bindings, rootPath: normalizedRootPath, isWorkspace });
+    depsToOptimize.set(dependency, {
+      exports: bindings,
+      rootPath: normalizedRootPath,
+      isWorkspace
+    });
   }
   async function checkTransitiveDependencies(internalMap, maxDepth = 10, currentDepth = 0) {
     if (currentDepth >= maxDepth) {
@@ -734,12 +775,18 @@ async function captureDependenciesToOptimize(output, workspaceMap, projectRoot,
       await checkTransitiveDependencies(internalMap, maxDepth, currentDepth + 1);
     }
   }
-  await checkTransitiveDependencies(initialDepsToOptimize);
+  if (shouldCheckTransitiveDependencies) {
+    await checkTransitiveDependencies(initialDepsToOptimize);
+  }
   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 });
+        depsToOptimize.set(dynamicImport, {
+          exports: ["*"],
+          rootPath: null,
+          isWorkspace: false
+        });
       }
     }
   }
@@ -753,8 +800,9 @@ async function analyzeEntry({
   sourcemapEnabled,
   workspaceMap,
   projectRoot,
-  initialDepsToOptimize = /* @__PURE__ */ new Map()
+  initialDepsToOptimize = /* @__PURE__ */ new Map(),
   // used to avoid infinite recursion
+  shouldCheckTransitiveDependencies = false
 }) {
   const optimizerBundler = await rollup({
     logLevel: process.env.MASTRA_BUNDLER_DEBUG === "true" ? "debug" : "silent",
@@ -775,7 +823,8 @@ async function analyzeEntry({
     projectRoot,
     initialDepsToOptimize,
     {
-      logger
+      logger,
+      shouldCheckTransitiveDependencies
     }
   );
   return {
@@ -786,6 +835,27 @@ async function analyzeEntry({
     }
   };
 }
+var FilenameDeclarationRegex = /(?:const|let|var)\s+__filename/;
+var DirnameDeclarationRegex = /(?:const|let|var)\s+__dirname/;
+function esmShim() {
+  const original = originalEsmShim();
+  return {
+    name: "esm-shim",
+    renderChunk(code, chunk, opts, meta) {
+      const hasFilename = code.includes("__filename");
+      const hasDirname = code.includes("__dirname");
+      const userDeclaredFilename = hasFilename && FilenameDeclarationRegex.test(code);
+      const userDeclaredDirname = hasDirname && DirnameDeclarationRegex.test(code);
+      if (userDeclaredFilename || userDeclaredDirname) {
+        return null;
+      }
+      if (typeof original.renderChunk === "function") {
+        return original.renderChunk.call(this, code, chunk, opts, meta);
+      }
+      return null;
+    }
+  };
+}
 function aliasHono() {
   return {
     name: "hono-alias",
@@ -798,6 +868,114 @@ function aliasHono() {
     }
   };
 }
+function nodeGypDetector() {
+  const modulesToTrack = /* @__PURE__ */ new Set();
+  const modulesToTrackPackageInfo = /* @__PURE__ */ new Map();
+  return {
+    name: "node-gyp-build-detector",
+    moduleParsed(info) {
+      if (!info.meta?.commonjs?.requires?.length) {
+        return;
+      }
+      const hasNodeGypBuild = info.meta.commonjs.requires.some(
+        (m) => m?.resolved?.id.endsWith("node-gyp-build/index.js")
+      );
+      if (!hasNodeGypBuild) {
+        return;
+      }
+      modulesToTrack.add(info.id);
+      modulesToTrackPackageInfo.set(info.id, getPackageInfo(info.id));
+    },
+    async generateBundle(options, bundle) {
+      const binaryMapByChunk = /* @__PURE__ */ new Map();
+      for (const [fileName, chunk] of Object.entries(bundle)) {
+        if (chunk.type === "chunk") {
+          for (const moduleId of chunk.moduleIds) {
+            if (modulesToTrackPackageInfo.has(moduleId)) {
+              const pkgInfo = await modulesToTrackPackageInfo.get(moduleId);
+              if (!binaryMapByChunk.has(fileName)) {
+                binaryMapByChunk.set(fileName, /* @__PURE__ */ new Set());
+              }
+              if (pkgInfo?.packageJson?.name) {
+                binaryMapByChunk.get(fileName).add(pkgInfo.packageJson.name);
+              }
+            }
+          }
+        }
+      }
+      const binaryMapJson = Object.fromEntries(
+        Array.from(binaryMapByChunk.entries()).map(([key, value]) => [key, Array.from(value)])
+      );
+      this.emitFile({
+        type: "asset",
+        name: "binary-map.json",
+        source: `${JSON.stringify(binaryMapJson, null, 2)}`
+      });
+    }
+  };
+}
+
+// src/build/plugins/subpath-externals-resolver.ts
+function subpathExternalsResolver(externals) {
+  return {
+    name: "subpath-externals-resolver",
+    resolveId(id) {
+      if (id.startsWith(".") || id.startsWith("/")) {
+        return null;
+      }
+      const isPartOfExternals = externals.some((external) => isDependencyPartOfPackage(id, external));
+      if (isPartOfExternals) {
+        return {
+          id,
+          external: true
+        };
+      }
+    }
+  };
+}
+function moduleResolveMap(externals, projectRoot) {
+  const importMap = /* @__PURE__ */ new Map();
+  return {
+    name: "module-resolve-map",
+    moduleParsed(info) {
+      if (info.importedIds.length === 0 || !info.id) {
+        return;
+      }
+      for (const importedId of info.importedIds) {
+        for (const external of externals) {
+          if (isDependencyPartOfPackage(importedId, external)) {
+            importMap.set(external, info.id);
+          }
+        }
+      }
+    },
+    async generateBundle(options, bundle) {
+      const resolveMap = /* @__PURE__ */ new Map();
+      for (const [fileName, chunk] of Object.entries(bundle)) {
+        if (chunk.type === "chunk") {
+          for (const [external, resolvedFrom] of importMap) {
+            if (chunk.moduleIds.includes(resolvedFrom)) {
+              const fullPath = pathToFileURL(slash(join(projectRoot, fileName))).toString();
+              const innerMap = resolveMap.get(fullPath) || /* @__PURE__ */ new Map();
+              innerMap.set(external, pathToFileURL(slash(resolvedFrom)).toString());
+              resolveMap.set(fullPath, innerMap);
+            }
+          }
+        }
+      }
+      const resolveMapJson = Object.fromEntries(
+        Array.from(resolveMap.entries()).map(([key, value]) => [key, Object.fromEntries(value.entries())])
+      );
+      this.emitFile({
+        type: "asset",
+        name: "module-resolve-map.json",
+        source: `${JSON.stringify(resolveMapJson, null, 2)}`
+      });
+    }
+  };
+}
+
+// src/build/analyze/bundleExternals.ts
 function prepareEntryFileName(name, rootDir) {
   return rollupSafeName(name, rootDir);
 }
@@ -863,7 +1041,8 @@ async function getInputPlugins2(virtualDependencies, {
   transpilePackages,
   workspaceMap,
   bundlerOptions,
-  rootDir
+  rootDir,
+  externals
 }) {
   const transpilePackagesMap = /* @__PURE__ */ new Map();
   for (const pkg2 of transpilePackages) {
@@ -884,6 +1063,7 @@ async function getInputPlugins2(virtualDependencies, {
         {}
       )
     ),
+    subpathExternalsResolver(externals),
     transpilePackagesMap.size ? esbuild({
       format: "esm",
       include: [...transpilePackagesMap.values()].map((p) => {
@@ -912,7 +1092,8 @@ async function getInputPlugins2(virtualDependencies, {
         if (!resolvedPath) {
           resolvedPath = pkgJson.main ?? "index.js";
         }
-        return await this.resolve(path2.posix.join(packageRootPath, resolvedPath), importer, options);
+        const resolved = await this.resolve(path2.posix.join(packageRootPath, resolvedPath), importer, options);
+        return resolved;
       }
     } : null,
     optimizeLodashImports({
@@ -931,6 +1112,8 @@ async function getInputPlugins2(virtualDependencies, {
     // hono is imported from deployer, so we need to resolve from here instead of the project root
     aliasHono(),
     json(),
+    nodeGypDetector(),
+    moduleResolveMap(externals, rootDir),
     {
       name: "not-found-resolver",
       resolveId: {
@@ -988,12 +1171,13 @@ async function buildExternalDependencies(virtualDependencies, {
       {}
     ),
     external: externals,
-    treeshake: "safest",
+    treeshake: bundlerOptions.isDev ? false : "safest",
     plugins: getInputPlugins2(virtualDependencies, {
       transpilePackages: packagesToTranspile,
       workspaceMap,
       bundlerOptions,
-      rootDir
+      rootDir,
+      externals
     })
   });
   const outputDirRelative = prepareEntryFileName(outputDir, rootDir);
@@ -1001,6 +1185,8 @@ async function buildExternalDependencies(virtualDependencies, {
     format: "esm",
     dir: rootDir,
     entryFileNames: "[name].mjs",
+    // used to get the filename of the actual error
+    sourcemap: true,
     /**
      * 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.
@@ -1038,6 +1224,7 @@ async function buildExternalDependencies(virtualDependencies, {
       }
       return `${outputDirRelative}/[name].mjs`;
     },
+    assetFileNames: `${outputDirRelative}/[name][extname]`,
     hoistTransitiveImports: false
   });
   await bundler.close();
@@ -1046,7 +1233,7 @@ async function buildExternalDependencies(virtualDependencies, {
 function findExternalImporter(module, external, allOutputs) {
   const capturedFiles = /* @__PURE__ */ new Set();
   for (const id of module.imports) {
-    if (id === external) {
+    if (isDependencyPartOfPackage(id, external)) {
       return module;
     } else {
       if (id.endsWith(".mjs")) {
@@ -1092,7 +1279,7 @@ async function bundleExternals(depsToOptimize, outputDir, options) {
       isDev
     }
   });
-  const moduleResolveMap = /* @__PURE__ */ new Map();
+  const moduleResolveMap2 = /* @__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) {
@@ -1102,10 +1289,10 @@ async function bundleExternals(depsToOptimize, outputDir, options) {
       const importer = findExternalImporter(o, external, filteredChunks);
       if (importer) {
         const fullPath = path2.join(workspaceRoot || projectRoot, importer.fileName);
-        let innerMap = moduleResolveMap.get(fullPath);
+        let innerMap = moduleResolveMap2.get(fullPath);
         if (!innerMap) {
           innerMap = /* @__PURE__ */ new Map();
-          moduleResolveMap.set(fullPath, innerMap);
+          moduleResolveMap2.set(fullPath, innerMap);
         }
         if (importer.moduleIds.length) {
           innerMap.set(
@@ -1117,7 +1304,7 @@ async function bundleExternals(depsToOptimize, outputDir, options) {
     }
   }
   const usedExternals = /* @__PURE__ */ Object.create(null);
-  for (const [fullPath, innerMap] of moduleResolveMap) {
+  for (const [fullPath, innerMap] of moduleResolveMap2) {
     const innerObj = /* @__PURE__ */ Object.create(null);
     for (const [external, value] of innerMap) {
       innerObj[external] = value;
@@ -1126,6 +1313,108 @@ async function bundleExternals(depsToOptimize, outputDir, options) {
   }
   return { output, fileNameToDependencyMap, usedExternals };
 }
+
+// ../../node_modules/.pnpm/stacktrace-parser@0.1.11/node_modules/stacktrace-parser/dist/stack-trace-parser.esm.js
+var UNKNOWN_FUNCTION = "<unknown>";
+function parse(stackString) {
+  var lines = stackString.split("\n");
+  return lines.reduce(function(stack, line) {
+    var parseResult = parseChrome(line) || parseWinjs(line) || parseGecko(line) || parseNode(line) || parseJSC(line);
+    if (parseResult) {
+      stack.push(parseResult);
+    }
+    return stack;
+  }, []);
+}
+var chromeRe = /^\s*at (.*?) ?\(((?:file|https?|blob|chrome-extension|native|eval|webpack|rsc|<anonymous>|\/|[a-z]:\\|\\\\).*?)(?::(\d+))?(?::(\d+))?\)?\s*$/i;
+var chromeEvalRe = /\((\S*)(?::(\d+))(?::(\d+))\)/;
+function parseChrome(line) {
+  var parts = chromeRe.exec(line);
+  if (!parts) {
+    return null;
+  }
+  var isNative = parts[2] && parts[2].indexOf("native") === 0;
+  var isEval = parts[2] && parts[2].indexOf("eval") === 0;
+  var submatch = chromeEvalRe.exec(parts[2]);
+  if (isEval && submatch != null) {
+    parts[2] = submatch[1];
+    parts[3] = submatch[2];
+    parts[4] = submatch[3];
+  }
+  return {
+    file: !isNative ? parts[2] : null,
+    methodName: parts[1] || UNKNOWN_FUNCTION,
+    arguments: isNative ? [parts[2]] : [],
+    lineNumber: parts[3] ? +parts[3] : null,
+    column: parts[4] ? +parts[4] : null
+  };
+}
+var winjsRe = /^\s*at (?:((?:\[object object\])?.+) )?\(?((?:file|ms-appx|https?|webpack|rsc|blob):.*?):(\d+)(?::(\d+))?\)?\s*$/i;
+function parseWinjs(line) {
+  var parts = winjsRe.exec(line);
+  if (!parts) {
+    return null;
+  }
+  return {
+    file: parts[2],
+    methodName: parts[1] || UNKNOWN_FUNCTION,
+    arguments: [],
+    lineNumber: +parts[3],
+    column: parts[4] ? +parts[4] : null
+  };
+}
+var geckoRe = /^\s*(.*?)(?:\((.*?)\))?(?:^|@)((?:file|https?|blob|chrome|webpack|rsc|resource|\[native).*?|[^@]*bundle)(?::(\d+))?(?::(\d+))?\s*$/i;
+var geckoEvalRe = /(\S+) line (\d+)(?: > eval line \d+)* > eval/i;
+function parseGecko(line) {
+  var parts = geckoRe.exec(line);
+  if (!parts) {
+    return null;
+  }
+  var isEval = parts[3] && parts[3].indexOf(" > eval") > -1;
+  var submatch = geckoEvalRe.exec(parts[3]);
+  if (isEval && submatch != null) {
+    parts[3] = submatch[1];
+    parts[4] = submatch[2];
+    parts[5] = null;
+  }
+  return {
+    file: parts[3],
+    methodName: parts[1] || UNKNOWN_FUNCTION,
+    arguments: parts[2] ? parts[2].split(",") : [],
+    lineNumber: parts[4] ? +parts[4] : null,
+    column: parts[5] ? +parts[5] : null
+  };
+}
+var javaScriptCoreRe = /^\s*(?:([^@]*)(?:\((.*?)\))?@)?(\S.*?):(\d+)(?::(\d+))?\s*$/i;
+function parseJSC(line) {
+  var parts = javaScriptCoreRe.exec(line);
+  if (!parts) {
+    return null;
+  }
+  return {
+    file: parts[3],
+    methodName: parts[1] || UNKNOWN_FUNCTION,
+    arguments: [],
+    lineNumber: +parts[4],
+    column: parts[5] ? +parts[5] : null
+  };
+}
+var nodeRe = /^\s*at (?:((?:\[object object\])?[^\\/]+(?: \[as \S+\])?) )?\(?(.*?):(\d+)(?::(\d+))?\)?\s*$/i;
+function parseNode(line) {
+  var parts = nodeRe.exec(line);
+  if (!parts) {
+    return null;
+  }
+  return {
+    file: parts[2],
+    methodName: parts[1] || UNKNOWN_FUNCTION,
+    arguments: [],
+    lineNumber: +parts[3],
+    column: parts[4] ? +parts[4] : null
+  };
+}
+
+// src/build/analyze.ts
 function throwExternalDependencyError({
   errorId,
   moduleName,
@@ -1149,6 +1438,110 @@ export const mastra = new Mastra({
 })`
   });
 }
+function getPackageNameFromBundledModuleName(moduleName) {
+  const chunks = moduleName.split("-");
+  if (!chunks.length) {
+    return moduleName;
+  }
+  if (chunks[0]?.startsWith("@")) {
+    return chunks.slice(0, 2).join("/");
+  }
+  return chunks[0];
+}
+function validateError(err, file, {
+  binaryMapData,
+  workspaceMap
+}) {
+  let moduleName = null;
+  let errorConfig = null;
+  if (err instanceof ValidationError) {
+    const parsedStack = parse(err.stack);
+    if (err.type === "TypeError") {
+      const pkgNameRegex = /.*node_modules\/([^\/]+)\//;
+      const stacktraceFrame = parsedStack.find((frame) => frame.file && pkgNameRegex.test(frame.file));
+      if (stacktraceFrame) {
+        const match = stacktraceFrame.file.match(pkgNameRegex);
+        moduleName = match?.[1] ?? getPackageNameFromBundledModuleName(basename$1(file.name));
+      } else {
+        moduleName = getPackageNameFromBundledModuleName(basename$1(file.name));
+      }
+      errorConfig = {
+        id: "DEPLOYER_ANALYZE_TYPE_ERROR",
+        messagePrefix: `Mastra wasn't able to bundle "${moduleName}", might be an older commonJS module. Please add`
+      };
+    } else if (err.stack?.includes?.("[ERR_MODULE_NOT_FOUND]")) {
+      moduleName = err.message.match(/Cannot find package '([^']+)'/)?.[1];
+      const parentModuleName = getPackageNameFromBundledModuleName(basename$1(file.name));
+      errorConfig = {
+        id: "DEPLOYER_ANALYZE_MODULE_NOT_FOUND",
+        messagePrefix: `Mastra wasn't able to build your project, We couldn't load "${moduleName}" from "${parentModuleName}". Make sure "${moduleName}" is installed or add`
+      };
+      if (moduleName === parentModuleName) {
+        return;
+      }
+    }
+  }
+  if (err.message.includes("No native build was found")) {
+    const pkgName = getPackageNameFromBundledModuleName(basename$1(file.name));
+    moduleName = binaryMapData[file.fileName]?.[0] ?? pkgName;
+    errorConfig = {
+      id: "DEPLOYER_ANALYZE_MISSING_NATIVE_BUILD",
+      messagePrefix: "We found a binary dependency in your bundle but we cannot bundle it yet. Please add"
+    };
+  }
+  if (moduleName && workspaceMap.has(moduleName)) {
+    throw new MastraError({
+      id: "DEPLOYER_ANALYZE_ERROR_IN_WORKSPACE",
+      domain: ErrorDomain.DEPLOYER,
+      category: ErrorCategory.USER,
+      details: {
+        // importFile: moduleName,
+        packageName: moduleName
+      },
+      text: `We found an error in the ${moduleName} workspace package. Please find the offending package and fix the error.
+  Error: ${err.stack}`
+    });
+  }
+  if (errorConfig && moduleName) {
+    throwExternalDependencyError({
+      errorId: errorConfig.id,
+      moduleName,
+      packageName: moduleName,
+      messagePrefix: errorConfig.messagePrefix
+    });
+  }
+}
+async function validateFile(root, file, {
+  binaryMapData,
+  moduleResolveMapLocation,
+  logger,
+  workspaceMap
+}) {
+  try {
+    if (!file.isDynamicEntry && file.isEntry) {
+      await validate(join(root, file.fileName), {
+        moduleResolveMapLocation,
+        injectESMShim: false
+      });
+    }
+  } catch (err) {
+    let errorToHandle = err;
+    if (err instanceof ValidationError && err.type === "ReferenceError" && (err.message.startsWith("__dirname") || err.message.startsWith("__filename"))) {
+      try {
+        await validate(join(root, file.fileName), {
+          moduleResolveMapLocation,
+          injectESMShim: true
+        });
+        errorToHandle = null;
+      } catch (err2) {
+        errorToHandle = err2;
+      }
+    }
+    if (errorToHandle instanceof Error) {
+      validateError(errorToHandle, file, { binaryMapData, workspaceMap });
+    }
+  }
+}
 async function validateOutput({
   output,
   reverseVirtualReferenceMap,
@@ -1162,60 +1555,30 @@ 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);
     }
   }
+  let binaryMapData = {};
+  if (existsSync(join(outputDir, "binary-map.json"))) {
+    const binaryMap = await readFile(join(outputDir, "binary-map.json"), "utf-8");
+    binaryMapData = JSON.parse(binaryMap);
+  }
   for (const file of output) {
     if (file.type === "asset") {
       continue;
     }
-    try {
-      logger.debug(`Validating if ${file.fileName} is a valid module.`);
-      if (file.isEntry && reverseVirtualReferenceMap.has(file.name)) {
-        result.dependencies.set(reverseVirtualReferenceMap.get(file.name), file.fileName);
-      }
-      if (!file.isDynamicEntry && file.isEntry) {
-        await validate(join(projectRoot, file.fileName));
-      }
-    } catch (err) {
-      if (err instanceof Error) {
-        let moduleName = null;
-        let errorConfig = null;
-        if (err.message.includes("[ERR_MODULE_NOT_FOUND]")) {
-          const moduleIdName = file.moduleIds.length >= 2 ? file.moduleIds[file.moduleIds.length - 2] : void 0;
-          const fallbackName = file.name.split("/").pop();
-          moduleName = moduleIdName ?? fallbackName;
-          errorConfig = {
-            id: "DEPLOYER_ANALYZE_MODULE_NOT_FOUND",
-            messagePrefix: "Mastra wasn't able to build your project. Please add"
-          };
-        } else if (err.message.includes("Error: No native build was found for ")) {
-          moduleName = findNativePackageModule(file.moduleIds);
-          errorConfig = {
-            id: "DEPLOYER_ANALYZE_MISSING_NATIVE_BUILD",
-            messagePrefix: "We found a binary dependency in your bundle. Please add"
-          };
-        }
-        if (moduleName && errorConfig) {
-          const pkgInfo = await getPackageInfo(moduleName);
-          const packageName = pkgInfo?.packageJson?.name;
-          if (packageName) {
-            throwExternalDependencyError({
-              errorId: errorConfig.id,
-              moduleName,
-              packageName,
-              messagePrefix: errorConfig.messagePrefix
-            });
-          } else {
-            logger.debug(`Could not determine the module name for file ${file.fileName}`);
-          }
-        }
-        logger.debug(`Error while validating module ${file.fileName}: ${err.message}`);
-      }
+    logger.debug(`Validating if ${file.fileName} is a valid module.`);
+    if (file.isEntry && reverseVirtualReferenceMap.has(file.name)) {
+      result.dependencies.set(reverseVirtualReferenceMap.get(file.name), file.fileName);
     }
+    await validateFile(projectRoot, file, {
+      binaryMapData,
+      moduleResolveMapLocation: join(outputDir, "module-resolve-map.json"),
+      logger,
+      workspaceMap
+    });
   }
   return result;
 }
@@ -1247,17 +1610,26 @@ If you think your configuration is valid, please open an issue.`);
   const { workspaceMap, workspaceRoot } = await getWorkspaceInformation({ mastraEntryFile: mastraEntry });
   let index = 0;
   const depsToOptimize = /* @__PURE__ */ new Map();
+  const { externals: customExternals = [] } = bundlerOptions || {};
+  const allExternals = [...GLOBAL_EXTERNALS, ...customExternals];
   logger.info("Analyzing dependencies...");
+  const allUsedExternals = /* @__PURE__ */ new Set();
   for (const entry of entries) {
     const isVirtualFile = entry.includes("\n") || !existsSync(entry);
     const analyzeResult = await analyzeEntry({ entry, isVirtualFile }, mastraEntry, {
       logger,
       sourcemapEnabled: bundlerOptions?.sourcemap ?? false,
       workspaceMap,
-      projectRoot
+      projectRoot,
+      shouldCheckTransitiveDependencies: isDev
     });
     await writeFile(join(outputDir, `entry-${index++}.mjs`), analyzeResult.output.code);
     for (const [dep, metadata] of analyzeResult.dependencies.entries()) {
+      const isPartOfExternals = allExternals.some((external) => isDependencyPartOfPackage(dep, external));
+      if (isPartOfExternals) {
+        allUsedExternals.add(dep);
+        continue;
+      }
       if (depsToOptimize.has(dep)) {
         const existingEntry = depsToOptimize.get(dep);
         depsToOptimize.set(dep, {
@@ -1276,14 +1648,13 @@ If you think your configuration is valid, please open an issue.`);
       }
     }
   }
-  logger.debug(`Analyzed dependencies: ${Array.from(depsToOptimize.keys()).join(", ")}`);
+  const sortedDeps = Array.from(depsToOptimize.keys()).sort();
   logger.info("Optimizing dependencies...");
-  logger.debug(
-    `${Array.from(depsToOptimize.keys()).map((key) => `- ${key}`).join("\n")}`
-  );
+  logger.debug(`${sortedDeps.map((key) => `- ${key}`).join("\n")}`);
   const { output, fileNameToDependencyMap, usedExternals } = await bundleExternals(depsToOptimize, outputDir, {
     bundlerOptions: {
       ...bundlerOptions,
+      externals: allExternals,
       enableEsmShim,
       isDev
     },
@@ -1302,9 +1673,12 @@ If you think your configuration is valid, please open an issue.`);
     },
     logger
   );
-  return result;
+  return {
+    ...result,
+    externalDependencies: /* @__PURE__ */ new Set([...result.externalDependencies, ...Array.from(allUsedExternals)])
+  };
 }
 
-export { aliasHono, analyzeBundle, esbuild, extractMastraOption, getBundlerOptions, getPackageName, getPackageRootPath, getWorkspaceInformation, removeAllOptionsFromMastraExcept, removeDeployer2 as removeDeployer, slash, tsConfigPaths };
-//# sourceMappingURL=chunk-NK3AYZ6D.js.map
-//# sourceMappingURL=chunk-NK3AYZ6D.js.map
+export { aliasHono, analyzeBundle, esbuild, esmShim, extractMastraOption, getBundlerOptions, getWorkspaceInformation, removeAllOptionsFromMastraExcept, removeDeployer2 as removeDeployer, subpathExternalsResolver, tsConfigPaths };
+//# sourceMappingURL=chunk-UEFVUIPU.js.map
+//# sourceMappingURL=chunk-UEFVUIPU.js.map