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

package/dist/{chunk-WFL4V5AW.cjs → chunk-PRPZEAA3.cjs}

@@ -1,12 +1,11 @@
 'use strict';
 
+var chunk2OTEFUER_cjs = require('./chunk-2OTEFUER.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');
@@ -18,11 +17,13 @@ var pkg = require('empathic/package');
 var findWorkspaces = require('find-workspaces');
 var logger = require('@mastra/core/logger');
 var virtual = require('@rollup/plugin-virtual');
+var url = require('url');
 var module$1 = require('module');
 var nodeResolve = require('@rollup/plugin-node-resolve');
 var esmShim = require('@rollup/plugin-esm-shim');
 var posix = require('path/posix');
 var resolve = require('resolve.exports');
+var localPkg = require('local-pkg');
 var error = require('@mastra/core/error');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -58,83 +59,18 @@ var nodeResolve__default = /*#__PURE__*/_interopDefault(nodeResolve);
 var esmShim__default = /*#__PURE__*/_interopDefault(esmShim);
 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,28 +80,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",
       undefined("@mastra/deployer/loader"),
       "--input-type=module",
+      "--enable-source-maps",
       "-e",
-      `import('file://${slash(file)}')`
+      `${prefixCode};import('file://${chunk2OTEFUER_cjs.slash(file)}').catch(err => {
+        ${errorHandler.toString()}
+        errorHandler(err);
+      })`.replaceAll(/\n/g, "")
     ],
     {
+      env: {
+        ...process.env,
+        MODULE_MAP: `${moduleResolveMapLocation}`
+      },
       cwd: path2.dirname(file)
     }
   );
@@ -261,28 +232,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__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 hasPaths(tsConfigPath2) {
+    try {
+      const config = JSON.parse(fs__default.default.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,
+          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.startsWith("\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 +321,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
           }
@@ -539,7 +575,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(chunk2OTEFUER_cjs.slash(closestPkgJson)) : chunk2OTEFUER_cjs.slash(process.cwd());
   const workspaces = await findWorkspaces.findWorkspaces(dir, { cache: workspacesCache });
   const _workspaceMap = new Map(
     workspaces?.map((workspace) => [
@@ -655,7 +691,7 @@ var DEPRECATED_EXTERNALS = ["fastembed", "nodemailer", "jsdom", "sqlite3"];
 
 // src/build/analyze/analyzeEntry.ts
 function getInputPlugins({ entry, isVirtualFile }, mastraEntry, { sourcemapEnabled }) {
-  const normalizedMastraEntry = slash(mastraEntry);
+  const normalizedMastraEntry = chunk2OTEFUER_cjs.slash(mastraEntry);
   let virtualPlugin = null;
   if (isVirtualFile) {
     virtualPlugin = virtual__default.default({
@@ -674,7 +710,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 chunk2OTEFUER_cjs.slash(url.fileURLToPath(undefined("@mastra/deployer/server")));
           }
           if (id === "#mastra") {
             return normalizedMastraEntry;
@@ -699,7 +735,8 @@ function getInputPlugins({ entry, isVirtualFile }, mastraEntry, { sourcemapEnabl
   return plugins;
 }
 async function captureDependenciesToOptimize(output, workspaceMap, projectRoot, initialDepsToOptimize, {
-  logger: logger$1
+  logger: logger$1,
+  shouldCheckTransitiveDependencies
 }) {
   const depsToOptimize = /* @__PURE__ */ new Map();
   if (!output.facadeModuleId) {
@@ -709,21 +746,25 @@ async function captureDependenciesToOptimize(output, workspaceMap, projectRoot,
   }
   let entryRootPath = projectRoot;
   if (!output.facadeModuleId.startsWith("\0virtual:")) {
-    entryRootPath = await getPackageRootPath(output.facadeModuleId) || projectRoot;
+    entryRootPath = await chunk2OTEFUER_cjs.getPackageRootPath(output.facadeModuleId) || projectRoot;
   }
   for (const [dependency, bindings] of Object.entries(output.importedBindings)) {
     if (isNodeBuiltin(dependency) || DEPS_TO_IGNORE.includes(dependency)) {
       continue;
     }
-    const pkgName = getPackageName(dependency);
+    const pkgName = chunk2OTEFUER_cjs.getPackageName(dependency);
     let rootPath = null;
     let isWorkspace = false;
     if (pkgName) {
-      rootPath = await getPackageRootPath(dependency, entryRootPath);
+      rootPath = await chunk2OTEFUER_cjs.getPackageRootPath(dependency, entryRootPath);
       isWorkspace = workspaceMap.has(pkgName);
     }
-    const normalizedRootPath = rootPath ? slash(rootPath) : null;
-    depsToOptimize.set(dependency, { exports: bindings, rootPath: normalizedRootPath, isWorkspace });
+    const normalizedRootPath = rootPath ? chunk2OTEFUER_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 +808,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,8 +833,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.rollup({
     logLevel: process.env.MASTRA_BUNDLER_DEBUG === "true" ? "debug" : "silent",
@@ -808,7 +856,8 @@ async function analyzeEntry({
     projectRoot,
     initialDepsToOptimize,
     {
-      logger
+      logger,
+      shouldCheckTransitiveDependencies
     }
   );
   return {
@@ -831,8 +880,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) => chunk2OTEFUER_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 (chunk2OTEFUER_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(chunk2OTEFUER_cjs.slash(path2.join(projectRoot, fileName))).toString();
+              const innerMap = resolveMap.get(fullPath) || /* @__PURE__ */ new Map();
+              innerMap.set(external, url.pathToFileURL(chunk2OTEFUER_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 chunk2OTEFUER_cjs.rollupSafeName(name, rootDir);
 }
 function createVirtualDependencies(depsToOptimize, {
   projectRoot,
@@ -882,7 +1039,7 @@ function createVirtualDependencies(depsToOptimize, {
         continue;
       }
       const fileName = posix.basename(currentDepPath.name);
-      const entryName = prepareEntryFileName(getCompiledDepCachePath(rootPath, fileName), rootDir);
+      const entryName = prepareEntryFileName(chunk2OTEFUER_cjs.getCompiledDepCachePath(rootPath, fileName), rootDir);
       fileNameToDependencyMap.set(entryName, dep);
       optimizedDependencyEntries.set(dep, {
         ...currentDepPath,
@@ -896,13 +1053,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);
+    const dir = await chunk2OTEFUER_cjs.getPackageRootPath(pkg2);
     if (dir) {
-      transpilePackagesMap.set(pkg2, slash(dir));
+      transpilePackagesMap.set(pkg2, chunk2OTEFUER_cjs.slash(dir));
     } else {
       transpilePackagesMap.set(pkg2, workspaceMap.get(pkg2)?.location ?? pkg2);
     }
@@ -917,6 +1075,7 @@ async function getInputPlugins2(virtualDependencies, {
         {}
       )
     ),
+    subpathExternalsResolver(externals),
     transpilePackagesMap.size ? esbuild({
       format: "esm",
       include: [...transpilePackagesMap.values()].map((p) => {
@@ -945,7 +1104,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({
@@ -964,6 +1124,8 @@ async function getInputPlugins2(virtualDependencies, {
     // 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: {
@@ -1021,12 +1183,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);
@@ -1034,6 +1197,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.
@@ -1042,9 +1207,9 @@ async function buildExternalDependencies(virtualDependencies, {
       if (bundlerOptions.isDev) {
         const importedFromPackages = /* @__PURE__ */ new Set();
         for (const moduleId of chunkInfo.moduleIds) {
-          const normalized = slash(moduleId);
+          const normalized = chunk2OTEFUER_cjs.slash(moduleId);
           for (const [pkgName, pkgInfo] of workspaceMap.entries()) {
-            const location = slash(pkgInfo.location);
+            const location = chunk2OTEFUER_cjs.slash(pkgInfo.location);
             if (normalized.startsWith(location)) {
               importedFromPackages.add(pkgName);
               break;
@@ -1066,11 +1231,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(chunk2OTEFUER_cjs.getCompiledDepCachePath(workspaceLocation, "[name].mjs"), rootDir);
         }
       }
       return `${outputDirRelative}/[name].mjs`;
     },
+    assetFileNames: `${outputDirRelative}/[name][extname]`,
     hoistTransitiveImports: false
   });
   await bundler.close();
@@ -1079,7 +1245,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 (chunk2OTEFUER_cjs.isDependencyPartOfPackage(id, external)) {
       return module;
     } else {
       if (id.endsWith(".mjs")) {
@@ -1125,7 +1291,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) {
@@ -1135,10 +1301,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,7 +1316,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;
@@ -1159,6 +1325,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,
@@ -1182,6 +1450,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 +1567,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;
 }
@@ -1280,17 +1622,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") || !fs.existsSync(entry);
     const analyzeResult = await analyzeEntry({ entry, isVirtualFile }, mastraEntry, {
       logger,
       sourcemapEnabled: bundlerOptions?.sourcemap ?? false,
       workspaceMap,
-      projectRoot
+      projectRoot,
+      shouldCheckTransitiveDependencies: isDev
     });
     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) => chunk2OTEFUER_cjs.isDependencyPartOfPackage(dep, external));
+      if (isPartOfExternals) {
+        allUsedExternals.add(dep);
+        continue;
+      }
       if (depsToOptimize.has(dep)) {
         const existingEntry = depsToOptimize.get(dep);
         depsToOptimize.set(dep, {
@@ -1309,14 +1660,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
     },
@@ -1335,7 +1685,10 @@ 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;
@@ -1343,12 +1696,10 @@ exports.analyzeBundle = analyzeBundle;
 exports.esbuild = esbuild;
 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-WFL4V5AW.cjs.map
-//# sourceMappingURL=chunk-WFL4V5AW.cjs.map
+//# sourceMappingURL=chunk-PRPZEAA3.cjs.map
+//# sourceMappingURL=chunk-PRPZEAA3.cjs.map