@mastra/deployer 1.0.0-beta.2 → 1.0.0-beta.21

package/dist/{chunk-C74EXQSL.cjs → chunk-NWQP6PZQ.cjs}

@@ -1,16 +1,17 @@
 'use strict';
 
+var chunk5TYVF4KJ_cjs = require('./chunk-5TYVF4KJ.cjs');
 var babel = require('@babel/core');
 var fs = require('fs');
 var promises = require('fs/promises');
 var path2 = require('path');
 var child_process = require('child_process');
-var localPkg = require('local-pkg');
 var url = require('url');
 var rollup = require('rollup');
 var originalEsbuild = require('rollup-plugin-esbuild');
 var commonjs = require('@rollup/plugin-commonjs');
 var resolveFrom2 = require('resolve-from');
+var stripJsonComments = require('strip-json-comments');
 var typescriptPaths = require('typescript-paths');
 var rollupPlugin = require('@optimize-lodash/rollup-plugin');
 var json = require('@rollup/plugin-json');
@@ -19,8 +20,9 @@ var findWorkspaces = require('find-workspaces');
 var logger = require('@mastra/core/logger');
 var virtual = require('@rollup/plugin-virtual');
 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 originalEsmShim = require('@rollup/plugin-esm-shim');
 var posix = require('path/posix');
 var resolve = require('resolve.exports');
 var error = require('@mastra/core/error');
@@ -51,90 +53,26 @@ var path2__namespace = /*#__PURE__*/_interopNamespace(path2);
 var originalEsbuild__default = /*#__PURE__*/_interopDefault(originalEsbuild);
 var commonjs__default = /*#__PURE__*/_interopDefault(commonjs);
 var resolveFrom2__default = /*#__PURE__*/_interopDefault(resolveFrom2);
+var stripJsonComments__default = /*#__PURE__*/_interopDefault(stripJsonComments);
 var json__default = /*#__PURE__*/_interopDefault(json);
 var pkg__namespace = /*#__PURE__*/_interopNamespace(pkg);
 var virtual__default = /*#__PURE__*/_interopDefault(virtual);
 var nodeResolve__default = /*#__PURE__*/_interopDefault(nodeResolve);
-var esmShim__default = /*#__PURE__*/_interopDefault(esmShim);
+var originalEsmShim__default = /*#__PURE__*/_interopDefault(originalEsmShim);
 var resolve__namespace = /*#__PURE__*/_interopNamespace(resolve);
 
-// src/build/analyze.ts
-function getPackageName(id) {
-  const parts = id.split("/");
-  if (id.startsWith("@")) {
-    return parts.slice(0, 2).join("/");
+var ValidationError = class extends Error {
+  type;
+  stack;
+  constructor(args) {
+    super(args.message);
+    this.type = args.type;
+    this.stack = args.stack;
   }
-  return parts[0];
-}
-async function getPackageRootPath(packageName, parentPath) {
-  let rootPath;
-  try {
-    let options = void 0;
-    if (parentPath) {
-      if (!parentPath.startsWith("file://")) {
-        parentPath = url.pathToFileURL(parentPath).href;
-      }
-      options = {
-        paths: [parentPath]
-      };
-    }
-    const pkg2 = await localPkg.getPackageInfo(packageName, options);
-    rootPath = pkg2?.rootPath ?? null;
-  } catch (e) {
-    rootPath = null;
-  }
-  return rootPath;
-}
-function getCompiledDepCachePath(rootPath, packageName) {
-  return slash(path2.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 = path2.relative(rootDir, name);
-  let entry = slash(rel);
-  entry = entry.replace(/^(\.\.\/)+/, "");
-  entry = entry.replace(/^\/+/, "");
-  entry = entry.replace(/^[A-Za-z]:\//, "");
-  if (!entry) {
-    entry = slash(path2.basename(name));
-  }
-  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 = child_process.spawn(command, args, {
       // stdio: 'inherit',
       ...options
@@ -144,113 +82,67 @@ 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",
       undefined("@mastra/deployer/loader"),
       "--input-type=module",
+      "--enable-source-maps",
       "-e",
-      `import('file://${slash(file)}')`
+      `${prefixCode};import('${url.pathToFileURL(file).href}').catch(err => {
+        ${errorHandler.toString()}
+        errorHandler(err);
+      })`.replaceAll(/\n/g, "")
     ],
     {
+      env: {
+        ...process.env,
+        MODULE_MAP: `${moduleResolveMapLocation}`
+      },
       cwd: path2.dirname(file)
     }
   );
 }
-function removeAllOptionsFromMastraExcept(result, option, logger) {
-  const t = babel__namespace.default.types;
-  return {
-    name: "remove-all-except-" + option + "-config",
-    visitor: {
-      ExportNamedDeclaration: {
-        // remove all exports
-        exit(path3) {
-          path3.remove();
-        }
-      },
-      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;
-        }
-        let mastraArgs = t.objectExpression([]);
-        if (t.isObjectExpression(path3.node.arguments[0])) {
-          mastraArgs = path3.node.arguments[0];
-        }
-        let configProperty = mastraArgs.properties.find(
-          // @ts-ignore
-          (prop) => prop.key.name === option
-        );
-        let configValue = t.objectExpression([]);
-        const programPath = path3.scope.getProgramParent().path;
-        if (!programPath) {
-          return;
-        }
-        if (configProperty && t.isObjectProperty(configProperty) && t.isExpression(configProperty.value)) {
-          result.hasCustomConfig = true;
-          configValue = configProperty.value;
-          if (t.isIdentifier(configProperty.value) && configProperty.value.name === option) {
-            const configBinding = state.file.scope.getBinding(option);
-            if (configBinding && t.isVariableDeclarator(configBinding.path.node)) {
-              const id = path3.scope.generateUidIdentifier(option);
-              configBinding.path.replaceWith(t.variableDeclarator(id, configBinding.path.node.init));
-              configValue = id;
-            }
-          }
-        }
-        const exportDeclaration = t.exportNamedDeclaration(
-          t.variableDeclaration("const", [t.variableDeclarator(t.identifier(option), configValue)]),
-          []
-        );
-        programPath.node.body.push(exportDeclaration);
-      },
-      Program: {
-        exit(path3) {
-          const hasExport = path3.node.body.some(
-            (node) => node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration"
-          );
-          if (!hasExport) {
-            if (logger) {
-              logger.warn(`Mastra ${option} config could not be extracted. Please make sure your entry file looks like this:
-export const mastra = new Mastra({
-  ${option}: <value>
-})
-
-`);
-            }
-            const fallbackExportDeclaration = t.exportNamedDeclaration(
-              t.variableDeclaration("const", [t.variableDeclarator(t.identifier(option), t.objectExpression([]))]),
-              []
-            );
-            path3.node.body.push(fallbackExportDeclaration);
-          }
-        }
-      }
-    }
-  };
-}
-
-// src/build/babel/remove-all-options-bundler.ts
-function removeAllOptionsExceptBundler(result, logger) {
-  return removeAllOptionsFromMastraExcept(result, "bundler", logger);
-}
 function esbuild(options = {}) {
   return originalEsbuild__default.default({
     target: "node20",
@@ -260,29 +152,90 @@ function esbuild(options = {}) {
   });
 }
 var PLUGIN_NAME = "tsconfig-paths";
+function hasPaths(tsConfigPath) {
+  try {
+    const content = fs__default.default.readFileSync(tsConfigPath, "utf8");
+    const config = JSON.parse(stripJsonComments__default.default(content));
+    return !!(config.compilerOptions?.paths && Object.keys(config.compilerOptions.paths).length > 0);
+  } catch {
+    return false;
+  }
+}
 function tsConfigPaths({ tsConfigPath, respectCoreModule, localResolve } = {}) {
-  let handler;
+  const handlerCache = /* @__PURE__ */ new Map();
+  function findTsConfigForFile(filePath) {
+    let currentDir = path2__namespace.default.dirname(filePath);
+    const root = path2__namespace.default.parse(currentDir).root;
+    while (currentDir !== root) {
+      const tsConfigPath2 = path2__namespace.default.join(currentDir, "tsconfig.json");
+      if (fs__default.default.existsSync(tsConfigPath2)) {
+        if (hasPaths(tsConfigPath2)) {
+          return tsConfigPath2;
+        }
+      }
+      const tsConfigBasePath = path2__namespace.default.join(currentDir, "tsconfig.base.json");
+      if (fs__default.default.existsSync(tsConfigBasePath)) {
+        if (hasPaths(tsConfigBasePath)) {
+          return tsConfigBasePath;
+        }
+      }
+      currentDir = path2__namespace.default.dirname(currentDir);
+    }
+    return null;
+  }
+  function getHandlerForFile(filePath) {
+    if (tsConfigPath && typeof tsConfigPath === "string") {
+      if (!handlerCache.has(tsConfigPath)) {
+        handlerCache.set(
+          tsConfigPath,
+          typescriptPaths.createHandler({
+            log: () => {
+            },
+            tsConfigPath,
+            respectCoreModule,
+            falllback: (moduleName) => fs__default.default.existsSync(moduleName)
+          })
+        );
+      }
+      return handlerCache.get(tsConfigPath);
+    }
+    const configPath = findTsConfigForFile(filePath);
+    if (!configPath) {
+      return null;
+    }
+    if (!handlerCache.has(configPath)) {
+      handlerCache.set(
+        configPath,
+        typescriptPaths.createHandler({
+          log: () => {
+          },
+          tsConfigPath: configPath,
+          respectCoreModule,
+          falllback: (moduleName) => fs__default.default.existsSync(moduleName)
+        })
+      );
+    }
+    return handlerCache.get(configPath);
+  }
+  function resolveAlias(request, importer) {
+    const dynamicHandler = getHandlerForFile(importer);
+    if (!dynamicHandler) {
+      return null;
+    }
+    const resolved = dynamicHandler(request, path2.normalize(importer));
+    return resolved;
+  }
   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")) {
+      if (!importer || request.startsWith("\0") || importer.charCodeAt(0) === 0) {
         return null;
       }
-      const moduleName = handler?.(request, path2.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) {
@@ -290,37 +243,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__namespace.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
           }
@@ -402,7 +360,117 @@ function recursiveRemoveNonReferencedNodes(code) {
     );
   });
 }
-function extractMastraOptionBundler(name, entryFile, transformer, result, logger) {
+function removeAllOptionsFromMastraExcept(result, option, logger) {
+  const t = babel__namespace.default.types;
+  return {
+    name: "remove-all-except-" + option + "-config",
+    visitor: {
+      ExportNamedDeclaration: {
+        // remove all exports
+        exit(path3) {
+          path3.remove();
+        }
+      },
+      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;
+        }
+        let mastraArgs = t.objectExpression([]);
+        if (t.isObjectExpression(path3.node.arguments[0])) {
+          mastraArgs = path3.node.arguments[0];
+        }
+        let configProperty = mastraArgs.properties.find(
+          (prop) => t.isObjectProperty(prop) && t.isIdentifier(prop.key) && prop.key.name === option
+        );
+        let configValue = t.objectExpression([]);
+        const programPath = path3.scope.getProgramParent().path;
+        if (!programPath) {
+          return;
+        }
+        if (configProperty && t.isObjectProperty(configProperty) && t.isExpression(configProperty.value)) {
+          result.hasCustomConfig = true;
+          configValue = configProperty.value;
+          if (t.isIdentifier(configProperty.value) && configProperty.value.name === option) {
+            const configBinding = state.file.scope.getBinding(option);
+            if (configBinding && t.isVariableDeclarator(configBinding.path.node)) {
+              const id = path3.scope.generateUidIdentifier(option);
+              configBinding.path.replaceWith(t.variableDeclarator(id, configBinding.path.node.init));
+              configValue = id;
+            }
+          }
+        }
+        const exportDeclaration = t.exportNamedDeclaration(
+          t.variableDeclaration("const", [t.variableDeclarator(t.identifier(option), configValue)]),
+          []
+        );
+        programPath.node.body.push(exportDeclaration);
+      },
+      Program: {
+        exit(path3) {
+          const hasExport = path3.node.body.some(
+            (node) => node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration"
+          );
+          if (!hasExport) {
+            if (logger) {
+              logger.warn(`Mastra ${option} config could not be extracted. Please make sure your entry file looks like this:
+export const mastra = new Mastra({
+  ${option}: <value>
+})
+
+`);
+            }
+            const fallbackExportDeclaration = t.exportNamedDeclaration(
+              t.variableDeclaration("const", [t.variableDeclarator(t.identifier(option), t.objectExpression([]))]),
+              []
+            );
+            path3.node.body.push(fallbackExportDeclaration);
+          }
+        }
+      }
+    }
+  };
+}
+
+// src/build/plugins/remove-all-except.ts
+function removeAllOptionsFromMastraExceptPlugin(mastraEntry, name, result, options) {
+  return {
+    name: `remove-${name}`,
+    transform(code, id) {
+      if (id !== mastraEntry) {
+        return;
+      }
+      return new Promise((resolve2, reject) => {
+        babel__namespace.transform(
+          code,
+          {
+            babelrc: false,
+            configFile: false,
+            filename: id,
+            plugins: [removeAllOptionsFromMastraExcept(result, name, options?.logger)],
+            sourceMaps: options?.sourcemap
+          },
+          (err, result2) => {
+            if (err) {
+              return reject(err);
+            }
+            resolve2({
+              code: result2.code,
+              map: result2.map
+            });
+          }
+        );
+      });
+    }
+  };
+}
+
+// src/build/shared/extract-mastra-option.ts
+function extractMastraOptionBundler(name, entryFile, result, logger) {
   return rollup.rollup({
     logLevel: "silent",
     input: {
@@ -423,34 +491,7 @@ function extractMastraOptionBundler(name, entryFile, transformer, result, logger
         ignoreTryCatch: false
       }),
       json__default.default(),
-      {
-        name: `extract-${name}-config`,
-        transform(code, id) {
-          if (id !== entryFile) {
-            return;
-          }
-          return new Promise((resolve2, reject) => {
-            babel__namespace.transform(
-              code,
-              {
-                babelrc: false,
-                configFile: false,
-                filename: id,
-                plugins: [transformer(result, logger)]
-              },
-              (err, result2) => {
-                if (err) {
-                  return reject(err);
-                }
-                resolve2({
-                  code: result2.code,
-                  map: result2.map
-                });
-              }
-            );
-          });
-        }
-      },
+      removeAllOptionsFromMastraExceptPlugin(entryFile, name, result, { logger }),
       // let esbuild remove all unused imports
       esbuild(),
       {
@@ -467,11 +508,11 @@ function extractMastraOptionBundler(name, entryFile, transformer, result, logger
     ]
   });
 }
-async function extractMastraOption(name, entryFile, transformer, outputDir, logger) {
+async function extractMastraOption(name, entryFile, outputDir, logger) {
   const result = {
     hasCustomConfig: false
   };
-  const bundler = await extractMastraOptionBundler(name, entryFile, transformer, result, logger);
+  const bundler = await extractMastraOptionBundler(name, entryFile, result, logger);
   const output = await bundler.write({
     dir: outputDir,
     format: "es",
@@ -481,7 +522,7 @@ async function extractMastraOption(name, entryFile, transformer, outputDir, logg
     const configPath = `${outputDir}/${name}-config.mjs`;
     return {
       bundleOutput: output,
-      getConfig: () => import(`file:${configPath}`).then((m) => m[name])
+      getConfig: () => import(url.pathToFileURL(configPath).href).then((m) => m[name])
     };
   }
   return null;
@@ -489,13 +530,7 @@ async function extractMastraOption(name, entryFile, transformer, outputDir, logg
 
 // src/build/bundlerOptions.ts
 async function getBundlerOptions(entryFile, outputDir, logger) {
-  const result = await extractMastraOption(
-    "bundler",
-    entryFile,
-    removeAllOptionsExceptBundler,
-    outputDir,
-    logger
-  );
+  const result = await extractMastraOption("bundler", entryFile, outputDir, logger);
   if (!result) {
     return null;
   }
@@ -539,7 +574,7 @@ async function getWorkspaceInformation({
   mastraEntryFile
 }) {
   const closestPkgJson = pkg__namespace.up({ cwd: path2.dirname(mastraEntryFile) });
-  const location = closestPkgJson ? path2.dirname(slash(closestPkgJson)) : slash(process.cwd());
+  const location = closestPkgJson ? path2.dirname(chunk5TYVF4KJ_cjs.slash(closestPkgJson)) : chunk5TYVF4KJ_cjs.slash(process.cwd());
   const workspaces = await findWorkspaces.findWorkspaces(dir, { cache: workspacesCache });
   const _workspaceMap = new Map(
     workspaces?.map((workspace) => [
@@ -564,8 +599,57 @@ function isNodeBuiltin(dep) {
   const [pkg2] = dep.split("/");
   return dep.startsWith("node:") || module$1.builtinModules.includes(dep) || module$1.builtinModules.includes(pkg2);
 }
+async function getPackageRootPath(packageName, parentPath) {
+  let rootPath;
+  try {
+    let options = void 0;
+    if (parentPath) {
+      if (!parentPath.startsWith("file://")) {
+        parentPath = url.pathToFileURL(parentPath).href;
+      }
+      options = {
+        paths: [parentPath]
+      };
+    }
+    const pkg2 = await localPkg.getPackageInfo(packageName, options);
+    rootPath = pkg2?.rootPath ?? null;
+  } catch (e) {
+    rootPath = null;
+  }
+  return rootPath;
+}
+
+// src/build/analyze/constants.ts
+var DEPS_TO_IGNORE = ["#tools"];
+var GLOBAL_EXTERNALS = [
+  "pino",
+  "pino-pretty",
+  "@libsql/client",
+  "pg",
+  "libsql",
+  "#tools",
+  "typescript",
+  "undici",
+  "readable-stream"
+];
+var DEPRECATED_EXTERNALS = ["fastembed", "nodemailer", "jsdom", "sqlite3"];
 function removeDeployer() {
   const t = babel__namespace.default.types;
+  function removeDeployerFromObject(objectExpr, scope) {
+    const deployerProp = objectExpr.properties.find(
+      (prop) => t.isObjectProperty(prop) && t.isIdentifier(prop.key) && prop.key.name === "deployer"
+    );
+    if (deployerProp) {
+      objectExpr.properties = objectExpr.properties.filter((prop) => prop !== deployerProp);
+      if (t.isIdentifier(deployerProp.value)) {
+        const deployerBinding = scope.getBinding(deployerProp.value.name);
+        if (deployerBinding) {
+          deployerBinding.path?.parentPath?.remove();
+        }
+      }
+    }
+    return deployerProp;
+  }
   return {
     name: "remove-deployer",
     visitor: {
@@ -581,23 +665,30 @@ function removeDeployer() {
         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;
+          if (t.isObjectExpression(newMastraObj.arguments[0]) && newMastraObj.arguments[0].properties?.length) {
+            const objectArg = newMastraObj.arguments[0];
+            let foundDeployer = false;
+            const directDeployer = removeDeployerFromObject(objectArg, state.file.scope);
+            if (directDeployer) {
+              foundDeployer = true;
             }
-            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();
+            for (const prop of objectArg.properties) {
+              if (t.isSpreadElement(prop) && t.isIdentifier(prop.argument)) {
+                const spreadBinding = state.file.scope.getBinding(prop.argument.name);
+                if (spreadBinding?.path && t.isVariableDeclarator(spreadBinding.path.node)) {
+                  const init = spreadBinding.path.node.init;
+                  if (t.isObjectExpression(init)) {
+                    const spreadDeployer = removeDeployerFromObject(init, state.file.scope);
+                    if (spreadDeployer) {
+                      foundDeployer = true;
+                    }
+                  }
+                }
               }
             }
-            path3.replaceWith(newMastraObj);
+            if (foundDeployer) {
+              path3.replaceWith(newMastraObj);
+            }
           }
         }
       }
@@ -638,24 +729,9 @@ function removeDeployer2(mastraEntry, options) {
   };
 }
 
-// src/build/analyze/constants.ts
-var DEPS_TO_IGNORE = ["#tools"];
-var GLOBAL_EXTERNALS = [
-  "pino",
-  "pino-pretty",
-  "@libsql/client",
-  "pg",
-  "libsql",
-  "#tools",
-  "typescript",
-  "undici",
-  "readable-stream"
-];
-var DEPRECATED_EXTERNALS = ["fastembed", "nodemailer", "jsdom", "sqlite3"];
-
 // src/build/analyze/analyzeEntry.ts
 function getInputPlugins({ entry, isVirtualFile }, mastraEntry, { sourcemapEnabled }) {
-  const normalizedMastraEntry = slash(mastraEntry);
+  const normalizedMastraEntry = chunk5TYVF4KJ_cjs.slash(mastraEntry);
   let virtualPlugin = null;
   if (isVirtualFile) {
     virtualPlugin = virtual__default.default({
@@ -674,7 +750,7 @@ function getInputPlugins({ entry, isVirtualFile }, mastraEntry, { sourcemapEnabl
         name: "custom-alias-resolver",
         resolveId(id) {
           if (id === "#server") {
-            return slash(url.fileURLToPath(undefined("@mastra/deployer/server")));
+            return chunk5TYVF4KJ_cjs.slash(url.fileURLToPath(undefined("@mastra/deployer/server")));
           }
           if (id === "#mastra") {
             return normalizedMastraEntry;
@@ -692,14 +768,17 @@ function getInputPlugins({ entry, isVirtualFile }, mastraEntry, { sourcemapEnabl
         transformMixedEsModules: true,
         extensions: [".js", ".ts"]
       }),
-      removeDeployer2(mastraEntry, { sourcemap: sourcemapEnabled }),
+      removeDeployer2(mastraEntry, {
+        sourcemap: sourcemapEnabled
+      }),
       esbuild()
     ]
   );
   return plugins;
 }
 async function captureDependenciesToOptimize(output, workspaceMap, projectRoot, initialDepsToOptimize, {
-  logger: logger$1
+  logger: logger$1,
+  shouldCheckTransitiveDependencies
 }) {
   const depsToOptimize = /* @__PURE__ */ new Map();
   if (!output.facadeModuleId) {
@@ -712,18 +791,22 @@ 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);
+    const pkgName = chunk5TYVF4KJ_cjs.getPackageName(dependency);
     let rootPath = null;
     let isWorkspace = false;
     if (pkgName) {
       rootPath = await getPackageRootPath(dependency, entryRootPath);
       isWorkspace = workspaceMap.has(pkgName);
     }
-    const normalizedRootPath = rootPath ? slash(rootPath) : null;
-    depsToOptimize.set(dependency, { exports: bindings, rootPath: normalizedRootPath, isWorkspace });
+    const normalizedRootPath = rootPath ? chunk5TYVF4KJ_cjs.slash(rootPath) : null;
+    depsToOptimize.set(dependency, {
+      exports: bindings,
+      rootPath: normalizedRootPath,
+      isWorkspace
+    });
   }
   async function checkTransitiveDependencies(internalMap, maxDepth = 10, currentDepth = 0) {
     if (currentDepth >= maxDepth) {
@@ -767,12 +850,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
+        });
       }
     }
   }
@@ -786,13 +875,14 @@ 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.rollup({
     logLevel: process.env.MASTRA_BUNDLER_DEBUG === "true" ? "debug" : "silent",
     input: isVirtualFile ? "#entry" : entry,
-    treeshake: "smallest",
+    treeshake: false,
     preserveSymlinks: true,
     plugins: getInputPlugins({ entry, isVirtualFile }, mastraEntry, { sourcemapEnabled }),
     external: DEPS_TO_IGNORE
@@ -808,7 +898,8 @@ async function analyzeEntry({
     projectRoot,
     initialDepsToOptimize,
     {
-      logger
+      logger,
+      shouldCheckTransitiveDependencies
     }
   );
   return {
@@ -819,6 +910,27 @@ async function analyzeEntry({
     }
   };
 }
+var FilenameDeclarationRegex = /(?:const|let|var)\s+__filename/;
+var DirnameDeclarationRegex = /(?:const|let|var)\s+__dirname/;
+function esmShim() {
+  const original = originalEsmShim__default.default();
+  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",
@@ -831,8 +943,116 @@ 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, localPkg.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) => chunk5TYVF4KJ_cjs.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 (chunk5TYVF4KJ_cjs.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 = url.pathToFileURL(chunk5TYVF4KJ_cjs.slash(path2.join(projectRoot, fileName))).toString();
+              const innerMap = resolveMap.get(fullPath) || /* @__PURE__ */ new Map();
+              innerMap.set(external, url.pathToFileURL(chunk5TYVF4KJ_cjs.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);
+  return chunk5TYVF4KJ_cjs.rollupSafeName(name, rootDir);
 }
 function createVirtualDependencies(depsToOptimize, {
   projectRoot,
@@ -840,7 +1060,7 @@ function createVirtualDependencies(depsToOptimize, {
   outputDir,
   bundlerOptions
 }) {
-  const { isDev = false } = bundlerOptions || {};
+  const { isDev = false, externalsPreset = false } = bundlerOptions || {};
   const fileNameToDependencyMap = /* @__PURE__ */ new Map();
   const optimizedDependencyEntries = /* @__PURE__ */ new Map();
   const rootDir = workspaceRoot || projectRoot;
@@ -872,7 +1092,7 @@ function createVirtualDependencies(depsToOptimize, {
       virtual: virtualFile.join("\n")
     });
   }
-  if (isDev) {
+  if (isDev || externalsPreset) {
     for (const [dep, { isWorkspace, rootPath }] of depsToOptimize.entries()) {
       if (!isWorkspace || !rootPath || !workspaceRoot) {
         continue;
@@ -882,7 +1102,7 @@ function createVirtualDependencies(depsToOptimize, {
         continue;
       }
       const fileName = posix.basename(currentDepPath.name);
-      const entryName = prepareEntryFileName(getCompiledDepCachePath(rootPath, fileName), rootDir);
+      const entryName = prepareEntryFileName(chunk5TYVF4KJ_cjs.getCompiledDepCachePath(rootPath, fileName), rootDir);
       fileNameToDependencyMap.set(entryName, dep);
       optimizedDependencyEntries.set(dep, {
         ...currentDepPath,
@@ -896,13 +1116,14 @@ async function getInputPlugins2(virtualDependencies, {
   transpilePackages,
   workspaceMap,
   bundlerOptions,
-  rootDir
+  rootDir,
+  externals
 }) {
   const transpilePackagesMap = /* @__PURE__ */ new Map();
   for (const pkg2 of transpilePackages) {
     const dir = await getPackageRootPath(pkg2);
     if (dir) {
-      transpilePackagesMap.set(pkg2, slash(dir));
+      transpilePackagesMap.set(pkg2, chunk5TYVF4KJ_cjs.slash(dir));
     } else {
       transpilePackagesMap.set(pkg2, workspaceMap.get(pkg2)?.location ?? pkg2);
     }
@@ -917,6 +1138,7 @@ async function getInputPlugins2(virtualDependencies, {
         {}
       )
     ),
+    subpathExternalsResolver(externals),
     transpilePackagesMap.size ? esbuild({
       format: "esm",
       include: [...transpilePackagesMap.values()].map((p) => {
@@ -927,7 +1149,7 @@ async function getInputPlugins2(virtualDependencies, {
         }
       })
     }) : null,
-    bundlerOptions.isDev ? {
+    bundlerOptions.noBundling ? {
       name: "alias-optimized-deps",
       async resolveId(id, importer, options) {
         if (!virtualDependencies.has(id)) {
@@ -945,7 +1167,8 @@ async function getInputPlugins2(virtualDependencies, {
         if (!resolvedPath) {
           resolvedPath = pkgJson.main ?? "index.js";
         }
-        return await this.resolve(path2__namespace.posix.join(packageRootPath, resolvedPath), importer, options);
+        const resolved = await this.resolve(path2__namespace.posix.join(packageRootPath, resolvedPath), importer, options);
+        return resolved;
       }
     } : null,
     rollupPlugin.optimizeLodashImports({
@@ -956,14 +1179,16 @@ async function getInputPlugins2(virtualDependencies, {
       transformMixedEsModules: true,
       ignoreTryCatch: false
     }),
-    bundlerOptions.isDev ? null : nodeResolve__default.default({
+    bundlerOptions.noBundling ? null : nodeResolve__default.default({
       preferBuiltins: true,
       exportConditions: ["node"]
     }),
-    bundlerOptions.isDev ? esmShim__default.default() : null,
+    bundlerOptions.noBundling ? esmShim() : null,
     // hono is imported from deployer, so we need to resolve from here instead of the project root
     aliasHono(),
     json__default.default(),
+    nodeGypDetector(),
+    moduleResolveMap(externals, rootDir),
     {
       name: "not-found-resolver",
       resolveId: {
@@ -1011,6 +1236,16 @@ async function buildExternalDependencies(virtualDependencies, {
   if (virtualDependencies.size === 0) {
     return [];
   }
+  const noBundling = bundlerOptions.isDev || bundlerOptions.externalsPreset;
+  const plugins = await getInputPlugins2(virtualDependencies, {
+    transpilePackages: packagesToTranspile,
+    workspaceMap,
+    bundlerOptions: {
+      noBundling
+    },
+    rootDir,
+    externals
+  });
   const bundler = await rollup.rollup({
     logLevel: process.env.MASTRA_BUNDLER_DEBUG === "true" ? "debug" : "silent",
     input: Array.from(virtualDependencies.entries()).reduce(
@@ -1021,30 +1256,27 @@ async function buildExternalDependencies(virtualDependencies, {
       {}
     ),
     external: externals,
-    treeshake: "safest",
-    plugins: getInputPlugins2(virtualDependencies, {
-      transpilePackages: packagesToTranspile,
-      workspaceMap,
-      bundlerOptions,
-      rootDir
-    })
+    treeshake: noBundling ? false : "safest",
+    plugins
   });
   const outputDirRelative = prepareEntryFileName(outputDir, rootDir);
   const { output } = await bundler.write({
     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.
      */
     chunkFileNames: (chunkInfo) => {
-      if (bundlerOptions.isDev) {
+      if (noBundling) {
         const importedFromPackages = /* @__PURE__ */ new Set();
         for (const moduleId of chunkInfo.moduleIds) {
-          const normalized = slash(moduleId);
+          const normalized = chunk5TYVF4KJ_cjs.slash(moduleId);
           for (const [pkgName, pkgInfo] of workspaceMap.entries()) {
-            const location = slash(pkgInfo.location);
+            const location = chunk5TYVF4KJ_cjs.slash(pkgInfo.location);
             if (normalized.startsWith(location)) {
               importedFromPackages.add(pkgName);
               break;
@@ -1066,11 +1298,12 @@ async function buildExternalDependencies(virtualDependencies, {
         if (importedFromPackages.size === 1) {
           const [pkgName] = importedFromPackages;
           const workspaceLocation = workspaceMap.get(pkgName).location;
-          return prepareEntryFileName(getCompiledDepCachePath(workspaceLocation, "[name].mjs"), rootDir);
+          return prepareEntryFileName(chunk5TYVF4KJ_cjs.getCompiledDepCachePath(workspaceLocation, "[name].mjs"), rootDir);
         }
       }
       return `${outputDirRelative}/[name].mjs`;
     },
+    assetFileNames: `${outputDirRelative}/[name][extname]`,
     hoistTransitiveImports: false
   });
   await bundler.close();
@@ -1079,7 +1312,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 (chunk5TYVF4KJ_cjs.isDependencyPartOfPackage(id, external)) {
       return module;
     } else {
       if (id.endsWith(".mjs")) {
@@ -1100,19 +1333,31 @@ function findExternalImporter(module, external, allOutputs) {
 }
 async function bundleExternals(depsToOptimize, outputDir, options) {
   const { workspaceRoot = null, workspaceMap = /* @__PURE__ */ new Map(), projectRoot = outputDir, bundlerOptions = {} } = options;
-  const {
-    externals: customExternals = [],
-    transpilePackages = [],
-    isDev = false} = bundlerOptions || {};
-  const allExternals = [...GLOBAL_EXTERNALS, ...DEPRECATED_EXTERNALS, ...customExternals];
+  const { externals: customExternals = [], transpilePackages = [], isDev = false } = bundlerOptions || {};
+  let externalsPreset = false;
+  if (customExternals === true) {
+    externalsPreset = true;
+  }
+  const externalsList = Array.isArray(customExternals) ? customExternals : [];
+  const allExternals = [...GLOBAL_EXTERNALS, ...DEPRECATED_EXTERNALS, ...externalsList];
   const workspacePackagesNames = Array.from(workspaceMap.keys());
   const packagesToTranspile = /* @__PURE__ */ new Set([...transpilePackages, ...workspacePackagesNames]);
+  const extractedExternals = /* @__PURE__ */ new Map();
+  if (externalsPreset) {
+    for (const [dep, metadata] of depsToOptimize.entries()) {
+      if (!metadata.isWorkspace) {
+        extractedExternals.set(dep, metadata.rootPath ?? dep);
+        depsToOptimize.delete(dep);
+      }
+    }
+  }
   const { optimizedDependencyEntries, fileNameToDependencyMap } = createVirtualDependencies(depsToOptimize, {
     workspaceRoot,
     outputDir,
     projectRoot,
     bundlerOptions: {
-      isDev
+      isDev,
+      externalsPreset
     }
   });
   const output = await buildExternalDependencies(optimizedDependencyEntries, {
@@ -1122,10 +1367,11 @@ async function bundleExternals(depsToOptimize, outputDir, options) {
     rootDir: workspaceRoot || projectRoot,
     outputDir,
     bundlerOptions: {
-      isDev
+      isDev,
+      externalsPreset
     }
   });
-  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) {
@@ -1135,10 +1381,10 @@ async function bundleExternals(depsToOptimize, outputDir, options) {
       const importer = findExternalImporter(o, external, filteredChunks);
       if (importer) {
         const fullPath = path2__namespace.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(
@@ -1150,15 +1396,125 @@ 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;
     }
     usedExternals[fullPath] = innerObj;
   }
+  if (extractedExternals.size > 0) {
+    const syntheticPath = path2__namespace.join(workspaceRoot || projectRoot, "__externals__");
+    const externalsObj = /* @__PURE__ */ Object.create(null);
+    for (const [dep, rootPath] of extractedExternals) {
+      externalsObj[dep] = rootPath;
+    }
+    usedExternals[syntheticPath] = externalsObj;
+  }
   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,
@@ -1182,6 +1538,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(path2.basename(file.name));
+      } else {
+        moduleName = getPackageNameFromBundledModuleName(path2.basename(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(path2.basename(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(path2.basename(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 error.MastraError({
+      id: "DEPLOYER_ANALYZE_ERROR_IN_WORKSPACE",
+      domain: error.ErrorDomain.DEPLOYER,
+      category: error.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(path2.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(path2.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,
@@ -1195,60 +1655,30 @@ 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);
     }
   }
+  let binaryMapData = {};
+  if (fs.existsSync(path2.join(outputDir, "binary-map.json"))) {
+    const binaryMap = await promises.readFile(path2.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(path2.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 localPkg.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: path2.join(outputDir, "module-resolve-map.json"),
+      logger,
+      workspaceMap
+    });
   }
   return result;
 }
@@ -1256,7 +1686,7 @@ async function analyzeBundle(entries, mastraEntry, {
   outputDir,
   projectRoot,
   isDev = false,
-  bundlerOptions: _bundlerOptions
+  bundlerOptions
 }, logger) {
   const mastraConfig = await promises.readFile(mastraEntry, "utf-8");
   const mastraConfigResult = {
@@ -1275,22 +1705,33 @@ export const mastra = new Mastra({
   
 If you think your configuration is valid, please open an issue.`);
   }
-  const { enableEsmShim = true } = _bundlerOptions || {};
-  const bundlerOptions = await getBundlerOptions(mastraEntry, outputDir);
   const { workspaceMap, workspaceRoot } = await getWorkspaceInformation({ mastraEntryFile: mastraEntry });
+  let externalsPreset = false;
+  const userExternals = Array.isArray(bundlerOptions?.externals) ? bundlerOptions?.externals : [];
+  if (bundlerOptions?.externals === true) {
+    externalsPreset = true;
+  }
   let index = 0;
   const depsToOptimize = /* @__PURE__ */ new Map();
+  const allExternals = [...GLOBAL_EXTERNALS, ...userExternals].filter(Boolean);
   logger.info("Analyzing dependencies...");
+  const allUsedExternals = /* @__PURE__ */ new Set();
   for (const entry of entries) {
     const isVirtualFile = entry.includes("\n") || !fs.existsSync(entry);
     const analyzeResult = await analyzeEntry({ entry, isVirtualFile }, mastraEntry, {
       logger,
-      sourcemapEnabled: bundlerOptions?.sourcemap ?? false,
+      sourcemapEnabled: bundlerOptions?.enableSourcemap ?? false,
       workspaceMap,
-      projectRoot
+      projectRoot,
+      shouldCheckTransitiveDependencies: isDev || externalsPreset
     });
     await promises.writeFile(path2.join(outputDir, `entry-${index++}.mjs`), analyzeResult.output.code);
     for (const [dep, metadata] of analyzeResult.dependencies.entries()) {
+      const isPartOfExternals = allExternals.some((external) => chunk5TYVF4KJ_cjs.isDependencyPartOfPackage(dep, external));
+      if (isPartOfExternals || externalsPreset && !metadata.isWorkspace) {
+        allUsedExternals.add(dep);
+        continue;
+      }
       if (depsToOptimize.has(dep)) {
         const existingEntry = depsToOptimize.get(dep);
         depsToOptimize.set(dep, {
@@ -1302,28 +1743,49 @@ If you think your configuration is valid, please open an issue.`);
       }
     }
   }
-  if (isDev) {
+  if (isDev || externalsPreset) {
     for (const [dep, metadata] of depsToOptimize.entries()) {
       if (!metadata.isWorkspace) {
         depsToOptimize.delete(dep);
       }
     }
   }
-  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,
-      enableEsmShim,
+      externals: bundlerOptions?.externals ?? allExternals,
       isDev
     },
     projectRoot,
     workspaceRoot,
     workspaceMap
   });
+  const relativeWorkspaceFolderPaths = Array.from(workspaceMap.values()).map(
+    (pkgInfo) => path2.relative(workspaceRoot || projectRoot, pkgInfo.location)
+  );
+  for (const o of output) {
+    if (o.type === "asset") {
+      continue;
+    }
+    for (const i of o.imports) {
+      if (chunk5TYVF4KJ_cjs.isBuiltinModule(i)) {
+        continue;
+      }
+      if (i.startsWith(".") || i.startsWith("/")) {
+        continue;
+      }
+      if (relativeWorkspaceFolderPaths.some((workspacePath) => i.startsWith(workspacePath))) {
+        continue;
+      }
+      const pkgName = chunk5TYVF4KJ_cjs.getPackageName(i);
+      if (pkgName) {
+        allUsedExternals.add(pkgName);
+      }
+    }
+  }
   const result = await validateOutput(
     {
       output,
@@ -1335,20 +1797,22 @@ 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)])
+  };
 }
 
 exports.aliasHono = aliasHono;
 exports.analyzeBundle = analyzeBundle;
 exports.esbuild = esbuild;
+exports.esmShim = esmShim;
 exports.extractMastraOption = extractMastraOption;
 exports.getBundlerOptions = getBundlerOptions;
-exports.getPackageName = getPackageName;
 exports.getPackageRootPath = getPackageRootPath;
 exports.getWorkspaceInformation = getWorkspaceInformation;
-exports.removeAllOptionsFromMastraExcept = removeAllOptionsFromMastraExcept;
 exports.removeDeployer = removeDeployer2;
-exports.slash = slash;
+exports.subpathExternalsResolver = subpathExternalsResolver;
 exports.tsConfigPaths = tsConfigPaths;
-//# sourceMappingURL=chunk-C74EXQSL.cjs.map
-//# sourceMappingURL=chunk-C74EXQSL.cjs.map
+//# sourceMappingURL=chunk-NWQP6PZQ.cjs.map
+//# sourceMappingURL=chunk-NWQP6PZQ.cjs.map