@mastra/deployer 1.54.0-alpha.0 → 1.54.0-alpha.2

package/dist/analyze-DhDZW9TS.cjs

@@ -0,0 +1,1318 @@
+const require_rolldown_runtime = require("./rolldown-runtime-emK7D4bc.cjs");
+const require_utils = require("./utils-O98BGdnP.cjs");
+require("./services-BxYMLS9-.cjs");
+const require_bundler = require("./bundler-BqrDXofn.cjs");
+let child_process = require("child_process");
+let fs = require("fs");
+let fs_promises = require("fs/promises");
+let path = require("path");
+path = require_rolldown_runtime.__toESM(path, 1);
+let _mastra_core_error = require("@mastra/core/error");
+let _rollup_plugin_virtual = require("@rollup/plugin-virtual");
+_rollup_plugin_virtual = require_rolldown_runtime.__toESM(_rollup_plugin_virtual, 1);
+let empathic_package = require("empathic/package");
+empathic_package = require_rolldown_runtime.__toESM(empathic_package, 1);
+let _babel_core = require("@babel/core");
+require("@sindresorhus/slugify");
+let find_workspaces = require("find-workspaces");
+require("fs-extra");
+let url = require("url");
+let _rollup_plugin_commonjs = require("@rollup/plugin-commonjs");
+_rollup_plugin_commonjs = require_rolldown_runtime.__toESM(_rollup_plugin_commonjs, 1);
+let _rollup_plugin_json = require("@rollup/plugin-json");
+_rollup_plugin_json = require_rolldown_runtime.__toESM(_rollup_plugin_json, 1);
+let rollup = require("rollup");
+let _optimize_lodash_rollup_plugin = require("@optimize-lodash/rollup-plugin");
+let _rollup_plugin_node_resolve = require("@rollup/plugin-node-resolve");
+_rollup_plugin_node_resolve = require_rolldown_runtime.__toESM(_rollup_plugin_node_resolve, 1);
+let local_pkg = require("local-pkg");
+let path_posix = require("path/posix");
+let resolve_exports = require("resolve.exports");
+resolve_exports = require_rolldown_runtime.__toESM(resolve_exports, 1);
+//#region ../../../../../setup-pnpm/node_modules/.bin/store/v11/links/@/stacktrace-parser/0.1.11/63406bc765474556691ebd1b24eaa0c5b032f058a26bbaff13797a2780d98220/node_modules/stacktrace-parser/dist/stack-trace-parser.cjs.js
+var require_stack_trace_parser_cjs = /* @__PURE__ */ require_rolldown_runtime.__commonJSMin(((exports) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	var UNKNOWN_FUNCTION = "<unknown>";
+	/**
+	* This parses the different stack traces and puts them into one format
+	* This borrows heavily from TraceKit (https://github.com/csnover/TraceKit)
+	*/
+	function parse(stackString) {
+		return stackString.split("\n").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
+		};
+	}
+	exports.parse = parse;
+}));
+//#endregion
+//#region src/bundler/workspaceDependencies.ts
+var import_stack_trace_parser_cjs = /* @__PURE__ */ require_rolldown_runtime.__toESM(require_stack_trace_parser_cjs(), 1);
+/**
+* Create a shared cache for find-workspaces
+*/
+const workspacesCache = (0, find_workspaces.createWorkspacesCache)();
+/**
+* A utility function around find-workspaces to get information about:
+* - Which workspace packages are available in the project
+* - What is the workspace root location
+* - Is the current package a workspace package
+*
+* Because `findWorkspacesRoot` only traverses up until it finds workspace information, but doesn't check if the current package is even part of the workspace. We rather want to return `null` for these cases because in other code paths we use `workspaceRoot || projectRoot` to determine the root of the project.
+*
+* @params dir - The directory to start searching from (default: `process.cwd()`)
+* @params location - The location of the current package (usually the directory containing the package.json)
+*/
+async function getWorkspaceInformation({ dir = process.cwd(), mastraEntryFile }) {
+	const closestPkgJson = empathic_package.up({ cwd: (0, path.dirname)(mastraEntryFile) });
+	const location = closestPkgJson ? (0, path.dirname)(require_utils.slash(closestPkgJson)) : require_utils.slash(process.cwd());
+	const workspaces = await (0, find_workspaces.findWorkspaces)(dir, { cache: workspacesCache });
+	const _workspaceMap = new Map(workspaces?.map((workspace) => [workspace.package.name, {
+		location: workspace.location,
+		dependencies: workspace.package.dependencies,
+		version: workspace.package.version
+	}]) ?? []);
+	const isWorkspacePackage = (workspaces ?? []).some((ws) => ws.location === location);
+	const workspaceRoot = isWorkspacePackage ? (0, find_workspaces.findWorkspacesRoot)(dir, { cache: workspacesCache })?.location : void 0;
+	return {
+		workspaceMap: isWorkspacePackage ? _workspaceMap : /* @__PURE__ */ new Map(),
+		workspaceRoot,
+		isWorkspacePackage
+	};
+}
+//#endregion
+//#region src/validator/validate.ts
+var ValidationError = class extends Error {
+	type;
+	stack;
+	constructor(args) {
+		super(args.message);
+		this.type = args.type;
+		this.stack = args.stack;
+	}
+};
+/**
+* Promisified version of Node.js spawn function
+*
+* @param command - The command to run
+* @param args - List of string arguments
+* @param options - Spawn options
+* @returns Promise that resolves with the exit code when the process completes
+*/
+function spawn(command, args = [], options = {}) {
+	return new Promise((resolve, reject) => {
+		let validationError = null;
+		const childProcess = (0, child_process.spawn)(command, args, {
+			stdio: [
+				"ignore",
+				"ignore",
+				"pipe"
+			],
+			...options
+		});
+		childProcess.on("error", (error) => {
+			reject(error);
+		});
+		let stderr = "";
+		childProcess.stderr?.on("data", (message) => {
+			try {
+				validationError = JSON.parse(message.toString());
+			} catch {
+				stderr += message;
+			}
+		});
+		childProcess.on("close", (code) => {
+			if (code === 0) resolve();
+			else if (validationError) reject(new ValidationError(validationError));
+			else reject(new Error(stderr));
+		});
+	});
+}
+function validate(file, { injectESMShim = false, moduleResolveMapLocation, stubbedExternals = [] }) {
+	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(process.execPath, [
+		"--import",
+		{}.resolve("@mastra/deployer/loader"),
+		"--input-type=module",
+		"--enable-source-maps",
+		"-e",
+		`${prefixCode};import('${(0, url.pathToFileURL)(file).href}').catch(err => {
+        ${errorHandler.toString()}
+        errorHandler(err);
+      })`.replaceAll(/\n/g, "")
+	], {
+		env: {
+			...process.env,
+			MODULE_MAP: `${moduleResolveMapLocation}`,
+			STUBBED_EXTERNALS: JSON.stringify(stubbedExternals)
+		},
+		cwd: (0, path.dirname)(file)
+	});
+}
+//#endregion
+//#region src/build/analyze/constants.ts
+const DEPS_TO_IGNORE = [
+	"#tools",
+	"execa",
+	"effect",
+	"sury",
+	"@ast-grep/napi",
+	"@hono/node-ws"
+];
+const GLOBAL_EXTERNALS = [
+	"pino",
+	"pino-pretty",
+	"@libsql/client",
+	"pg",
+	"libsql",
+	"#tools",
+	"typescript",
+	"undici",
+	"readable-stream",
+	"bufferutil",
+	"utf-8-validate",
+	"execa",
+	"@ast-grep/napi",
+	"@hono/node-ws"
+];
+const DEPRECATED_EXTERNALS = [
+	"fastembed",
+	"nodemailer",
+	"jsdom",
+	"sqlite3"
+];
+//#endregion
+//#region src/build/analyze/analyzeEntry.ts
+/**
+* Configures and returns the Rollup plugins needed for analyzing entry files.
+* Sets up module resolution, transpilation, and custom alias handling for Mastra-specific imports.
+*/
+function getInputPlugins$1({ entry, isVirtualFile }, mastraEntry, { sourcemapEnabled }) {
+	let virtualPlugin = null;
+	if (isVirtualFile) {
+		virtualPlugin = (0, _rollup_plugin_virtual.default)({ "#entry": entry });
+		entry = "#entry";
+	}
+	const plugins = [];
+	if (virtualPlugin) plugins.push(virtualPlugin);
+	plugins.push(...[
+		require_bundler.protocolExternalResolver(),
+		require_bundler.mastraInternalAliasPlugin(mastraEntry),
+		require_bundler.mastraToolsAliasPlugin(),
+		require_bundler.tsConfigPaths(),
+		(0, _rollup_plugin_json.default)(),
+		require_bundler.esbuild(),
+		(0, _rollup_plugin_commonjs.default)({
+			strictRequires: "debug",
+			ignoreTryCatch: false,
+			transformMixedEsModules: true,
+			extensions: [".js", ".ts"]
+		}),
+		require_bundler.removeDeployer(mastraEntry, { sourcemap: sourcemapEnabled }),
+		require_bundler.esbuild()
+	]);
+	return plugins;
+}
+/**
+* Extracts and categorizes dependencies from Rollup output to determine which ones need optimization.
+* Analyzes both static imports and dynamic imports while filtering out Node.js built-ins and ignored dependencies.
+* Identifies workspace packages and resolves package root paths for proper bundling optimization.
+*/
+async function captureDependenciesToOptimize(output, workspaceMap, projectRoot, { logger, shouldCheckTransitiveDependencies }) {
+	const depsToOptimize = /* @__PURE__ */ new Map();
+	if (!output.facadeModuleId) throw new Error("Something went wrong, we could not find the package name of the entry file. Please open an issue.");
+	let entryRootPath = projectRoot;
+	if (!output.facadeModuleId.startsWith("\0virtual:")) entryRootPath = await require_bundler.getPackageRootPath(output.facadeModuleId) || projectRoot;
+	for (const [dependency, bindings] of Object.entries(output.importedBindings)) {
+		if (!require_utils.isBareModuleSpecifier(dependency)) continue;
+		const pkgName = require_utils.getPackageName(dependency);
+		let rootPath = null;
+		let isWorkspace = false;
+		let version;
+		let packageSpec;
+		if (pkgName) {
+			const metadata = await require_bundler.getPackageMetadata(dependency, entryRootPath);
+			rootPath = metadata.rootPath;
+			version = metadata.version;
+			packageSpec = metadata.packageSpec;
+			isWorkspace = workspaceMap.has(pkgName);
+		}
+		const normalizedRootPath = rootPath ? require_utils.slash(rootPath) : null;
+		depsToOptimize.set(dependency, {
+			exports: bindings,
+			rootPath: normalizedRootPath,
+			isWorkspace,
+			version,
+			packageSpec
+		});
+	}
+	const processedWorkspaceDeps = /* @__PURE__ */ new Set();
+	/**
+	* Recursively discovers transitive workspace dependencies from package manifests.
+	*/
+	function checkTransitiveDependencies(maxDepth = 10, currentDepth = 0) {
+		if (currentDepth >= maxDepth) {
+			logger.warn("Maximum dependency depth reached while checking transitive dependencies.");
+			return;
+		}
+		const depsSnapshot = new Map(depsToOptimize);
+		let hasAddedDeps = false;
+		for (const [dep, meta] of depsSnapshot) {
+			const pkgName = require_utils.getPackageName(dep);
+			if (!pkgName || !meta.isWorkspace || processedWorkspaceDeps.has(pkgName)) continue;
+			processedWorkspaceDeps.add(pkgName);
+			const workspaceInfo = workspaceMap.get(pkgName);
+			if (!workspaceInfo?.dependencies) continue;
+			for (const [innerDep, _innerDepVersion] of Object.entries(workspaceInfo.dependencies)) {
+				const innerWorkspaceInfo = workspaceMap.get(innerDep);
+				if (!innerWorkspaceInfo) continue;
+				const existingMeta = depsToOptimize.get(innerDep);
+				if (existingMeta) {
+					depsToOptimize.set(innerDep, {
+						...existingMeta,
+						exports: existingMeta.exports.includes("*") ? existingMeta.exports : [...existingMeta.exports, "*"]
+					});
+					continue;
+				}
+				depsToOptimize.set(innerDep, {
+					exports: ["*"],
+					rootPath: require_utils.slash(innerWorkspaceInfo.location),
+					isWorkspace: true,
+					version: innerWorkspaceInfo.version
+				});
+				hasAddedDeps = true;
+			}
+		}
+		if (hasAddedDeps) checkTransitiveDependencies(maxDepth, currentDepth + 1);
+	}
+	if (shouldCheckTransitiveDependencies) checkTransitiveDependencies();
+	const dynamicImports = output.dynamicImports.filter((d) => !DEPS_TO_IGNORE.includes(d));
+	if (dynamicImports.length) {
+		for (const dynamicImport of dynamicImports) if (!depsToOptimize.has(dynamicImport) && require_utils.isBareModuleSpecifier(dynamicImport)) {
+			const pkgName = require_utils.getPackageName(dynamicImport);
+			let version;
+			let packageSpec;
+			let rootPath = null;
+			if (pkgName) {
+				const metadata = await require_bundler.getPackageMetadata(dynamicImport, entryRootPath);
+				rootPath = metadata.rootPath;
+				version = metadata.version;
+				packageSpec = metadata.packageSpec;
+			}
+			depsToOptimize.set(dynamicImport, {
+				exports: ["*"],
+				rootPath: rootPath ? require_utils.slash(rootPath) : null,
+				isWorkspace: false,
+				version,
+				packageSpec
+			});
+		}
+	}
+	return depsToOptimize;
+}
+async function analyzeEntry({ entry, isVirtualFile }, mastraEntry, { logger, sourcemapEnabled, workspaceMap, projectRoot, shouldCheckTransitiveDependencies = false, analyzeCache }) {
+	const cacheKey = isVirtualFile ? void 0 : require_utils.slash(entry);
+	if (cacheKey && analyzeCache?.has(cacheKey)) return analyzeCache.get(cacheKey);
+	const optimizerBundler = await (0, rollup.rollup)({
+		logLevel: process.env.MASTRA_BUNDLER_DEBUG === "true" ? "debug" : "silent",
+		input: isVirtualFile ? "#entry" : entry,
+		treeshake: false,
+		preserveSymlinks: true,
+		plugins: getInputPlugins$1({
+			entry,
+			isVirtualFile
+		}, mastraEntry, { sourcemapEnabled }),
+		external: DEPS_TO_IGNORE
+	});
+	const { output } = await optimizerBundler.generate({
+		format: "esm",
+		inlineDynamicImports: true
+	});
+	await optimizerBundler.close();
+	const result = {
+		dependencies: await captureDependenciesToOptimize(output[0], workspaceMap, projectRoot, {
+			logger,
+			shouldCheckTransitiveDependencies
+		}),
+		output: {
+			code: output[0].code,
+			map: output[0].map
+		}
+	};
+	if (cacheKey && analyzeCache) analyzeCache.set(cacheKey, result);
+	return result;
+}
+//#endregion
+//#region src/build/plugins/hono-alias.ts
+function aliasHono() {
+	return {
+		name: "hono-alias",
+		resolveId(id) {
+			if (!id.startsWith("@hono/") && !id.startsWith("hono/") && id !== "hono" && id !== "hono-openapi") return;
+			return (0, url.fileURLToPath)({}.resolve(id));
+		}
+	};
+}
+//#endregion
+//#region src/build/plugins/module-resolve-map.ts
+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 (require_utils.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 = (0, url.pathToFileURL)(require_utils.slash((0, path.join)(projectRoot, fileName))).toString();
+					const innerMap = resolveMap.get(fullPath) || /* @__PURE__ */ new Map();
+					innerMap.set(external, (0, url.pathToFileURL)(require_utils.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)}`
+			});
+		}
+	};
+}
+//#endregion
+//#region src/build/plugins/node-gyp-detector.ts
+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;
+			if (!info.meta.commonjs.requires.some((m) => m?.resolved?.id.endsWith("node-gyp-build/index.js"))) return;
+			modulesToTrack.add(info.id);
+			modulesToTrackPackageInfo.set(info.id, (0, local_pkg.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)}`
+			});
+		}
+	};
+}
+//#endregion
+//#region src/build/analyze/bundleExternals.ts
+function prepareEntryFileName(name, rootDir) {
+	return require_utils.rollupSafeName(name, rootDir);
+}
+/**
+* Creates virtual dependency modules for optimized bundling by generating virtual entry points for each dependency with their specific exports and handling workspace package path resolution.
+*/
+function createVirtualDependencies(depsToOptimize, { projectRoot, workspaceRoot, outputDir, bundlerOptions }) {
+	const { isDev = false, externalsPreset = false } = bundlerOptions || {};
+	const fileNameToDependencyMap = /* @__PURE__ */ new Map();
+	const optimizedDependencyEntries = /* @__PURE__ */ new Map();
+	const rootDir = workspaceRoot || projectRoot;
+	for (const [dep, { exports }] of depsToOptimize.entries()) {
+		const fileName = dep.replaceAll("/", "__");
+		const virtualFile = [];
+		const exportStringBuilder = [];
+		for (const local of exports) if (local === "*") {
+			virtualFile.push(`export * from '${dep}';`);
+			continue;
+		} else if (local === "default") exportStringBuilder.push("default");
+		else exportStringBuilder.push(local);
+		const chunks = [];
+		if (exportStringBuilder.length) chunks.push(`{ ${exportStringBuilder.join(", ")} }`);
+		if (chunks.length) virtualFile.push(`export ${chunks.join(", ")} from '${dep}';`);
+		let entryName = prepareEntryFileName(path.join(outputDir, fileName), rootDir);
+		fileNameToDependencyMap.set(entryName, dep);
+		optimizedDependencyEntries.set(dep, {
+			name: entryName,
+			virtual: virtualFile.join("\n")
+		});
+	}
+	if (isDev || externalsPreset) for (const [dep, { isWorkspace, rootPath }] of depsToOptimize.entries()) {
+		if (!isWorkspace || !rootPath || !workspaceRoot) continue;
+		const currentDepPath = optimizedDependencyEntries.get(dep);
+		if (!currentDepPath) continue;
+		const entryName = prepareEntryFileName(require_utils.getCompiledDepCachePath(rootPath, (0, path_posix.basename)(currentDepPath.name)), rootDir);
+		fileNameToDependencyMap.set(entryName, dep);
+		optimizedDependencyEntries.set(dep, {
+			...currentDepPath,
+			name: entryName
+		});
+	}
+	return {
+		optimizedDependencyEntries,
+		fileNameToDependencyMap
+	};
+}
+/**
+* Configures and returns Rollup plugins for bundling external dependencies.
+* Sets up virtual modules, TypeScript compilation, CommonJS transformation, and workspace resolution.
+*/
+async function getInputPlugins(virtualDependencies, { transpilePackages, workspaceMap, bundlerOptions, rootDir, externals, platform }) {
+	const transpilePackagesMap = /* @__PURE__ */ new Map();
+	for (const pkg of transpilePackages) {
+		const dir = await require_bundler.getPackageRootPath(pkg);
+		if (dir) transpilePackagesMap.set(pkg, require_utils.slash(dir));
+		else transpilePackagesMap.set(pkg, workspaceMap.get(pkg)?.location ?? pkg);
+	}
+	return [
+		(0, _rollup_plugin_virtual.default)(Array.from(virtualDependencies.entries()).reduce((acc, [dep, virtualDep]) => {
+			acc[`#virtual-${dep}`] = virtualDep.virtual;
+			return acc;
+		}, {})),
+		require_bundler.tsConfigPaths(),
+		require_bundler.protocolExternalResolver(),
+		require_bundler.subpathExternalsResolver(externals),
+		transpilePackagesMap.size ? require_bundler.esbuild({
+			format: "esm",
+			include: [...[...transpilePackagesMap.values()].map((p) => {
+				if (path.isAbsolute(p)) return new RegExp(`^${p.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}/(?!.*node_modules).*$`);
+				else return new RegExp(`\/${p.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}/(?!.*node_modules).*$`);
+			}), ...[...transpilePackagesMap.keys()].map((pkgName) => {
+				const escapedPkgName = pkgName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+				return new RegExp(`/node_modules/${escapedPkgName}/(?!.*node_modules).*$`);
+			})],
+			exclude: []
+		}) : null,
+		bundlerOptions.noBundling ? {
+			name: "alias-optimized-deps",
+			async resolveId(id, importer, options) {
+				if (!virtualDependencies.has(id)) return null;
+				const info = virtualDependencies.get(id);
+				const packageRootPath = path.join(rootDir, path.dirname(path.dirname(path.dirname(info.name))));
+				const pkgJsonBuffer = await (0, fs_promises.readFile)(path.join(packageRootPath, "package.json"), "utf-8");
+				const pkgJson = JSON.parse(pkgJsonBuffer);
+				if (!pkgJson) return null;
+				const pkgName = pkgJson.name || "";
+				let resolvedPath = resolve_exports.exports(pkgJson, id.replace(pkgName, "."))?.[0];
+				if (!resolvedPath) resolvedPath = pkgJson.main ?? "index.js";
+				return await this.resolve(path.posix.join(packageRootPath, resolvedPath), importer, options);
+			}
+		} : null,
+		(0, _optimize_lodash_rollup_plugin.optimizeLodashImports)({ include: "**/*.{js,ts,mjs,cjs}" }),
+		(0, _rollup_plugin_commonjs.default)({
+			strictRequires: "strict",
+			transformMixedEsModules: true,
+			ignoreTryCatch: false
+		}),
+		bundlerOptions.noBundling ? null : (0, _rollup_plugin_node_resolve.default)(require_utils.getNodeResolveOptions(platform)),
+		bundlerOptions.noBundling ? require_bundler.esmShim() : null,
+		aliasHono(),
+		(0, _rollup_plugin_json.default)(),
+		nodeGypDetector(),
+		moduleResolveMap(externals, rootDir),
+		{
+			name: "not-found-resolver",
+			resolveId: {
+				order: "post",
+				async handler(id, importer) {
+					if (!importer) return null;
+					if (!id.endsWith(".node")) return null;
+					const packageName = (await (0, local_pkg.getPackageInfo)(importer))?.packageJson?.name || id;
+					throw new _mastra_core_error.MastraBaseError({
+						id: "DEPLOYER_BUNDLE_EXTERNALS_MISSING_NATIVE_BUILD",
+						domain: _mastra_core_error.ErrorDomain.DEPLOYER,
+						category: _mastra_core_error.ErrorCategory.USER,
+						details: {
+							importFile: importer,
+							packageName
+						},
+						text: `We found a possible binary dependency in your bundle. ${id} was not found when imported at ${importer}.
+
+Please consider adding \`${packageName}\` to your externals, or updating this import to not end with ".node".
+
+export const mastra = new Mastra({
+  bundler: {
+    externals: ["${packageName}"],
+  }
+})`
+					});
+				}
+			}
+		}
+	].filter(Boolean);
+}
+/**
+* Executes the Rollup build process for virtual dependencies using configured plugins.
+* Bundles all virtual dependency modules into optimized ESM files with proper external handling.
+*/
+async function buildExternalDependencies(virtualDependencies, { externals, packagesToTranspile, workspaceMap, rootDir, outputDir, bundlerOptions, platform }) {
+	/**
+	* If there are no virtual dependencies to bundle, return an empty array to avoid Rollup errors.
+	*/
+	if (virtualDependencies.size === 0) return [];
+	const noBundling = bundlerOptions.isDev || bundlerOptions.externalsPreset;
+	const plugins = await getInputPlugins(virtualDependencies, {
+		transpilePackages: packagesToTranspile,
+		workspaceMap,
+		bundlerOptions: { noBundling },
+		rootDir,
+		externals,
+		platform
+	});
+	const bundler = await (0, rollup.rollup)({
+		logLevel: process.env.MASTRA_BUNDLER_DEBUG === "true" ? "debug" : "silent",
+		input: Array.from(virtualDependencies.entries()).reduce((acc, [dep, virtualDep]) => {
+			acc[virtualDep.name] = `#virtual-${dep}`;
+			return acc;
+		}, {}),
+		external: externals,
+		treeshake: noBundling ? false : "safest",
+		plugins
+	});
+	const outputDirRelative = prepareEntryFileName(outputDir, rootDir);
+	const { output } = await bundler.write({
+		format: "esm",
+		dir: rootDir,
+		entryFileNames: "[name].mjs",
+		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) => {
+			/**
+			* This whole bunch of logic directly below is for the edge case shown in the e2e-tests/monorepo with "tinyrainbow" package. It's used in multiple places in the package and as such Rollup creates a shared chunk for it. During 'mastra dev' / with externals: true, we don't want that chunk to show up in the '.mastra/output' folder (outputDirRelative) but inside <pkg>/node_modules/.cache instead.
+			* We only care about this for the "noBundling" case!
+			*/
+			if (noBundling) {
+				const importedFromPackages = /* @__PURE__ */ new Set();
+				for (const moduleId of chunkInfo.moduleIds) {
+					const normalized = require_utils.slash(moduleId);
+					for (const [pkgName, pkgInfo] of workspaceMap.entries()) {
+						const location = require_utils.slash(pkgInfo.location);
+						if (normalized.startsWith(location)) {
+							importedFromPackages.add(pkgName);
+							break;
+						}
+					}
+				}
+				if (importedFromPackages.size > 1) throw new _mastra_core_error.MastraBaseError({
+					id: "DEPLOYER_BUNDLE_EXTERNALS_SHARED_CHUNK",
+					domain: _mastra_core_error.ErrorDomain.DEPLOYER,
+					category: _mastra_core_error.ErrorCategory.USER,
+					details: {
+						chunkName: chunkInfo.name,
+						packages: JSON.stringify(Array.from(importedFromPackages))
+					},
+					text: `Please open an issue. We found a shared chunk "${chunkInfo.name}" used by multiple workspace packages: ${Array.from(importedFromPackages).join(", ")}.`
+				});
+				if (importedFromPackages.size === 1) {
+					const [pkgName] = importedFromPackages;
+					const workspaceLocation = workspaceMap.get(pkgName).location;
+					return prepareEntryFileName(require_utils.getCompiledDepCachePath(workspaceLocation, "[name].mjs"), rootDir);
+				}
+			}
+			return `${outputDirRelative}/[name].mjs`;
+		},
+		assetFileNames: `${outputDirRelative}/[name][extname]`,
+		hoistTransitiveImports: false
+	});
+	await bundler.close();
+	return output;
+}
+/**
+* Recursively searches through Rollup output chunks to find which module imports a specific external dependency.
+* Used to build the module resolution map for proper external dependency tracking.
+*/
+function findExternalImporter(module, external, allOutputs, visited = /* @__PURE__ */ new Set()) {
+	if (visited.has(module.fileName)) return null;
+	visited.add(module.fileName);
+	const capturedFiles = /* @__PURE__ */ new Set();
+	for (const id of [...module.imports, ...module.dynamicImports]) if (require_utils.isDependencyPartOfPackage(id, external)) return module;
+	else if (id.endsWith(".mjs")) capturedFiles.add(id);
+	for (const file of capturedFiles) {
+		const nextModule = allOutputs.find((o) => o.fileName === file);
+		if (nextModule) {
+			const importer = findExternalImporter(nextModule, external, allOutputs, visited);
+			if (importer) return importer;
+		}
+	}
+	return null;
+}
+/**
+* Bundles vendor dependencies identified in the analysis step.
+* Creates virtual modules for each dependency and bundles them using rollup.
+*
+* @param depsToOptimize - Map of dependencies to optimize with their metadata (exported bindings, rootPath, isWorkspace)
+* @param outputDir - Directory where bundled files will be written
+* @param logger - Logger instance for debugging
+* @returns Object containing bundle output and reference map for validation
+*/
+async function bundleExternals(depsToOptimize, outputDir, options) {
+	const { workspaceRoot = null, workspaceMap = /* @__PURE__ */ new Map(), projectRoot = outputDir, bundlerOptions = {}, platform = "node" } = options;
+	const { externals: customExternals = [], transpilePackages = [], isDev = false } = bundlerOptions || {};
+	/**
+	* A user can set `externals: true` to indicate they want to externalize all dependencies. In this case, we set `externalsPreset` to true to skip bundling any externals.
+	*/
+	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]);
+	/**
+	* When externals: true, we need to extract non-workspace deps from depsToOptimize
+	* and add them directly to usedExternals instead of bundling them.
+	*/
+	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,
+			externalsPreset
+		}
+	});
+	const output = await buildExternalDependencies(optimizedDependencyEntries, {
+		externals: allExternals,
+		packagesToTranspile,
+		workspaceMap,
+		rootDir: workspaceRoot || projectRoot,
+		outputDir,
+		bundlerOptions: {
+			isDev,
+			externalsPreset
+		},
+		platform
+	});
+	const moduleResolveMap = /* @__PURE__ */ new Map();
+	const filteredChunks = output.filter((o) => o.type === "chunk");
+	for (const o of filteredChunks.filter((o) => o.isEntry || o.isDynamicEntry)) for (const external of allExternals) {
+		if (DEPS_TO_IGNORE.includes(external)) continue;
+		const importer = findExternalImporter(o, external, filteredChunks);
+		if (importer) {
+			const fullPath = path.join(workspaceRoot || projectRoot, importer.fileName);
+			let innerMap = moduleResolveMap.get(fullPath);
+			if (!innerMap) {
+				innerMap = /* @__PURE__ */ new Map();
+				moduleResolveMap.set(fullPath, innerMap);
+			}
+			if (importer.moduleIds.length) innerMap.set(external, importer.moduleIds[importer.moduleIds.length - 1]?.startsWith("\0virtual:#virtual") ? importer.moduleIds[importer.moduleIds.length - 2] : importer.moduleIds[importer.moduleIds.length - 1]);
+		}
+	}
+	/**
+	* Convert moduleResolveMap to a plain object with prototype-less objects
+	*/
+	const usedExternals = Object.create(null);
+	for (const [fullPath, innerMap] of moduleResolveMap) {
+		const innerObj = Object.create(null);
+		for (const [external, value] of innerMap) innerObj[external] = value;
+		usedExternals[fullPath] = innerObj;
+	}
+	/**
+	* When externals: true, add the extracted non-workspace deps to usedExternals
+	* using a synthetic entry path to track them.
+	*/
+	if (extractedExternals.size > 0) {
+		const syntheticPath = path.join(workspaceRoot || projectRoot, "__externals__");
+		const externalsObj = Object.create(null);
+		for (const [dep, rootPath] of extractedExternals) externalsObj[dep] = rootPath;
+		usedExternals[syntheticPath] = externalsObj;
+	}
+	return {
+		output,
+		fileNameToDependencyMap,
+		usedExternals
+	};
+}
+//#endregion
+//#region src/build/babel/check-config-export.ts
+function checkConfigExport(result) {
+	const mastraVars = /* @__PURE__ */ new Set();
+	return { visitor: {
+		NewExpression(path) {
+			if (!_babel_core.types.isIdentifier(path.node.callee)) return;
+			const binding = path.scope.getBinding(path.node.callee.name);
+			if (binding?.path.isImportSpecifier() && _babel_core.types.isIdentifier(binding.path.node.imported, { name: "MastraFactory" })) result.projectType = "factory";
+		},
+		ExportNamedDeclaration(path) {
+			const decl = path.node.declaration;
+			if (_babel_core.types.isVariableDeclaration(decl)) {
+				const varDecl = decl.declarations[0];
+				if (_babel_core.types.isIdentifier(varDecl?.id, { name: "mastra" }) && _babel_core.types.isNewExpression(varDecl.init) && _babel_core.types.isIdentifier(varDecl.init.callee, { name: "Mastra" })) result.hasValidConfig = true;
+			}
+			/**
+			* 2) export { foo as mastra }
+			* 3) export { mastra }
+			* 4) export { mastra, foo }
+			*/
+			if (Array.isArray(path.node.specifiers)) {
+				for (const spec of path.node.specifiers) if (_babel_core.types.isExportSpecifier(spec) && _babel_core.types.isIdentifier(spec.exported, { name: "mastra" }) && _babel_core.types.isIdentifier(spec.local) && mastraVars.has(spec.local.name)) result.hasValidConfig = true;
+			}
+		},
+		VariableDeclaration(path) {
+			for (const decl of path.node.declarations) if (_babel_core.types.isIdentifier(decl.id) && _babel_core.types.isNewExpression(decl.init) && _babel_core.types.isIdentifier(decl.init.callee, { name: "Mastra" })) mastraVars.add(decl.id.name);
+		}
+	} };
+}
+//#endregion
+//#region src/build/babel/detect-pino-transports.ts
+/**
+* Extract string value from a node (supports StringLiteral and TemplateLiteral without expressions)
+*/
+function getStringValue(node) {
+	if (!node) return null;
+	if (_babel_core.types.isStringLiteral(node)) return node.value;
+	if (_babel_core.types.isTemplateLiteral(node) && node.expressions.length === 0 && node.quasis.length === 1) return node.quasis[0]?.value.cooked ?? null;
+	return null;
+}
+/**
+* Extract target value from an object property
+*/
+function extractTargetFromProperty(prop) {
+	if (!_babel_core.types.isObjectProperty(prop)) return null;
+	const key = prop.key;
+	if (_babel_core.types.isIdentifier(key, { name: "target" }) || _babel_core.types.isStringLiteral(key) && key.value === "target") return getStringValue(prop.value);
+	return null;
+}
+/**
+* Check if a binding came from a pino import/require
+*/
+function isBindingFromPino(path, identifierName) {
+	const binding = path.scope.getBinding(identifierName);
+	if (!binding) return identifierName === "pino";
+	const bindingPath = binding.path;
+	if (bindingPath.isImportDefaultSpecifier()) {
+		const importDecl = bindingPath.parentPath;
+		if (importDecl?.isImportDeclaration()) return importDecl.node.source.value === "pino";
+	}
+	if (bindingPath.isImportNamespaceSpecifier()) {
+		const importDecl = bindingPath.parentPath;
+		if (importDecl?.isImportDeclaration()) return importDecl.node.source.value === "pino";
+	}
+	if (bindingPath.isImportSpecifier()) {
+		const importDecl = bindingPath.parentPath;
+		if (importDecl?.isImportDeclaration() && importDecl.node.source.value === "pino") {
+			const imported = bindingPath.node.imported;
+			if (_babel_core.types.isIdentifier(imported) && imported.name === "default") return true;
+			if (_babel_core.types.isStringLiteral(imported) && imported.value === "default") return true;
+		}
+		return false;
+	}
+	if (bindingPath.isVariableDeclarator()) {
+		const init = bindingPath.node.init;
+		if (_babel_core.types.isCallExpression(init) && _babel_core.types.isIdentifier(init.callee, { name: "require" }) && init.arguments.length === 1 && _babel_core.types.isStringLiteral(init.arguments[0]) && init.arguments[0].value === "pino") return true;
+	}
+	return false;
+}
+/**
+* Check if a call expression is a pino.transport() call using scope analysis
+*/
+function isPinoTransportCall(path) {
+	const callee = path.node.callee;
+	if (!_babel_core.types.isMemberExpression(callee)) return false;
+	if (!_babel_core.types.isIdentifier(callee.property, { name: "transport" })) return false;
+	if (_babel_core.types.isIdentifier(callee.object)) return isBindingFromPino(path, callee.object.name);
+	if (_babel_core.types.isMemberExpression(callee.object) && _babel_core.types.isIdentifier(callee.object.object) && _babel_core.types.isIdentifier(callee.object.property, { name: "default" })) return isBindingFromPino(path, callee.object.object.name);
+	return false;
+}
+/**
+* Extract transport targets from a pino.transport() argument
+*/
+function extractTransportsFromArg(arg) {
+	const targets = [];
+	if (!_babel_core.types.isObjectExpression(arg)) return targets;
+	for (const prop of arg.properties) {
+		if (!_babel_core.types.isObjectProperty(prop)) continue;
+		const key = prop.key;
+		const keyName = _babel_core.types.isIdentifier(key) ? key.name : _babel_core.types.isStringLiteral(key) ? key.value : null;
+		if (keyName === "target") {
+			const value = getStringValue(prop.value);
+			if (value) targets.push(value);
+		} else if (keyName === "targets") {
+			if (_babel_core.types.isArrayExpression(prop.value)) {
+				for (const element of prop.value.elements) if (_babel_core.types.isObjectExpression(element)) for (const innerProp of element.properties) {
+					const targetValue = extractTargetFromProperty(innerProp);
+					if (targetValue) targets.push(targetValue);
+				}
+			}
+		}
+	}
+	return targets;
+}
+/**
+* Babel plugin to detect pino transport targets in code.
+* Matches patterns like:
+* - pino.transport({ target: "package-name" })
+* - pino.transport({ targets: [{ target: "package-name" }] })
+* - variable.transport({ target: "..." }) where variable is assigned from pino import
+*
+* @param transports - Set to collect detected transport package names
+* @returns Babel plugin object
+*/
+function detectPinoTransports(transports) {
+	return {
+		name: "detect-pino-transports",
+		visitor: { CallExpression(path) {
+			if (!isPinoTransportCall(path)) return;
+			const firstArg = path.node.arguments[0];
+			if (firstArg && !_babel_core.types.isSpreadElement(firstArg)) for (const target of extractTransportsFromArg(firstArg)) transports.add(target);
+		} }
+	};
+}
+//#endregion
+//#region src/build/analyze.ts
+function preferDependencyInfo(existing, incoming) {
+	return {
+		version: incoming.version ?? existing?.version,
+		packageSpec: incoming.packageSpec ?? existing?.packageSpec
+	};
+}
+async function resolveDependencyInfo(dep, existing, parentPaths) {
+	if (existing?.version || existing?.packageSpec) return existing;
+	const packageName = require_utils.getPackageName(dep);
+	const packageNames = [...new Set([dep, packageName].filter(Boolean))];
+	for (const parentPath of parentPaths) for (const name of packageNames) {
+		const metadata = await require_bundler.getPackageMetadata(name, parentPath);
+		if (metadata.version || metadata.packageSpec) return preferDependencyInfo(existing, metadata);
+	}
+	for (const name of packageNames) {
+		const metadata = await require_bundler.getPackageMetadata(name);
+		if (metadata.version || metadata.packageSpec) return preferDependencyInfo(existing, metadata);
+	}
+	return existing ?? {};
+}
+function importerParentPaths(importerId, base) {
+	if (!importerId || importerId.startsWith("\0") || !(0, path.isAbsolute)(importerId)) return base;
+	return [.../* @__PURE__ */ new Set([importerId, ...base])];
+}
+function getLastConcreteModuleId(moduleIds) {
+	return moduleIds.findLast((id) => !id.startsWith("\0") && (0, path.isAbsolute)(id));
+}
+function throwExternalDependencyError({ errorId, moduleName, packageName, messagePrefix }) {
+	throw new _mastra_core_error.MastraError({
+		id: errorId,
+		domain: _mastra_core_error.ErrorDomain.DEPLOYER,
+		category: _mastra_core_error.ErrorCategory.USER,
+		details: {
+			importFile: moduleName,
+			packageName
+		},
+		text: `${messagePrefix} \`${packageName}\` to your externals.
+
+export const mastra = new Mastra({
+  bundler: {
+    externals: ["${packageName}"],
+  }
+})`
+	});
+}
+function getPackageNameFromBundledModuleName(moduleName) {
+	if (moduleName.includes("__")) return moduleName.replaceAll("__", "/");
+	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 = import_stack_trace_parser_cjs.parse(err.stack);
+		if (err.type === "TypeError") {
+			const pkgNameRegex = /.*node_modules\/([^\/]+)\//;
+			const stacktraceFrame = parsedStack.find((frame) => frame.file && pkgNameRegex.test(frame.file));
+			if (stacktraceFrame) moduleName = stacktraceFrame.file.match(pkgNameRegex)?.[1] ?? getPackageNameFromBundledModuleName((0, path.basename)(file.name));
+			else moduleName = getPackageNameFromBundledModuleName((0, path.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((0, path.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((0, path.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 _mastra_core_error.MastraError({
+		id: "DEPLOYER_ANALYZE_ERROR_IN_WORKSPACE",
+		domain: _mastra_core_error.ErrorDomain.DEPLOYER,
+		category: _mastra_core_error.ErrorCategory.USER,
+		details: { 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, stubbedExternals }) {
+	try {
+		if (!file.isDynamicEntry && file.isEntry) await validate((0, path.join)(root, file.fileName), {
+			moduleResolveMapLocation,
+			injectESMShim: false,
+			stubbedExternals
+		});
+	} catch (err) {
+		let errorToHandle = err;
+		if (err instanceof ValidationError && err.type === "ReferenceError" && (err.message.startsWith("__dirname") || err.message.startsWith("__filename"))) try {
+			await validate((0, path.join)(root, file.fileName), {
+				moduleResolveMapLocation,
+				injectESMShim: true,
+				stubbedExternals
+			});
+			errorToHandle = null;
+		} catch (err) {
+			errorToHandle = err;
+		}
+		if (errorToHandle instanceof Error) validateError(errorToHandle, file, {
+			binaryMapData,
+			logger,
+			workspaceMap
+		});
+	}
+}
+/**
+* Validates the bundled output by attempting to import each generated module.
+* Tracks external dependencies that couldn't be bundled.
+*
+* @param output - Bundle output from rollup
+* @param reverseVirtualReferenceMap - Map to resolve virtual module names back to original deps
+* @param outputDir - Directory containing the bundled files
+* @param logger - Logger instance for debugging
+* @param workspaceMap - Map of workspace packages that gets directly passed through for later consumption
+* @returns Analysis result containing dependency mappings
+*/
+async function validateOutput({ output, reverseVirtualReferenceMap, usedExternals, outputDir, projectRoot, workspaceMap, depsVersionInfo }, logger) {
+	const result = {
+		dependencies: /* @__PURE__ */ new Map(),
+		externalDependencies: /* @__PURE__ */ new Map(),
+		workspaceMap
+	};
+	const externalMetadataParentPaths = [projectRoot, ...Array.from(workspaceMap.values()).map((pkgInfo) => pkgInfo.location)];
+	for (const deps of Object.values(usedExternals)) for (const [dep, importerId] of Object.entries(deps)) {
+		if (require_utils.isExternalProtocolImport(dep)) continue;
+		const pkgName = require_utils.getPackageName(dep);
+		if (pkgName) {
+			const dependencyInfo = await resolveDependencyInfo(dep, depsVersionInfo.get(dep) || depsVersionInfo.get(pkgName), importerParentPaths(importerId, externalMetadataParentPaths));
+			result.externalDependencies.set(pkgName, preferDependencyInfo(result.externalDependencies.get(pkgName), dependencyInfo));
+		}
+	}
+	let binaryMapData = {};
+	if ((0, fs.existsSync)((0, path.join)(outputDir, "binary-map.json"))) {
+		const binaryMap = await (0, fs_promises.readFile)((0, path.join)(outputDir, "binary-map.json"), "utf-8");
+		binaryMapData = JSON.parse(binaryMap);
+	}
+	for (const file of output) {
+		if (file.type === "asset") continue;
+		logger.debug("Validating module", { fileName: file.fileName });
+		if (file.isEntry && reverseVirtualReferenceMap.has(file.name)) result.dependencies.set(reverseVirtualReferenceMap.get(file.name), file.fileName);
+		await validateFile(projectRoot, file, {
+			binaryMapData,
+			moduleResolveMapLocation: (0, path.join)(outputDir, "module-resolve-map.json"),
+			logger,
+			workspaceMap,
+			stubbedExternals: [...GLOBAL_EXTERNALS, ...DEPS_TO_IGNORE]
+		});
+	}
+	return result;
+}
+/**
+* Main bundle analysis function that orchestrates the three-step process:
+* 1. Analyze dependencies
+* 2. Bundle dependencies modules
+* 3. Validate generated bundles
+*
+* This helps identify which dependencies need to be externalized vs bundled.
+*/
+async function analyzeBundle(entries, mastraEntry, { outputDir, projectRoot, platform, isDev = false, bundlerOptions }, logger) {
+	const mastraConfig = await (0, fs_promises.readFile)(mastraEntry, "utf-8");
+	const mastraConfigResult = { hasValidConfig: false };
+	await (0, _babel_core.transformAsync)(mastraConfig, {
+		filename: mastraEntry,
+		presets: [{}.resolve("@babel/preset-typescript")],
+		plugins: [() => checkConfigExport(mastraConfigResult)]
+	});
+	if (!mastraConfigResult.hasValidConfig) logger.warn("Invalid Mastra config", { details: "Please make sure that your entry file looks like this:\nexport const mastra = new Mastra({\n  // your options\n})\n\nIf you think your configuration is valid, please open an issue." });
+	const { workspaceMap, workspaceRoot } = await getWorkspaceInformation({ mastraEntryFile: mastraEntry });
+	let externalsPreset = false;
+	const userExternals = Array.isArray(bundlerOptions?.externals) ? bundlerOptions?.externals : [];
+	const userDynamicPackages = bundlerOptions?.dynamicPackages ?? [];
+	if (bundlerOptions?.externals === true) externalsPreset = true;
+	let index = 0;
+	const depsToOptimize = /* @__PURE__ */ new Map();
+	const allExternals = [...GLOBAL_EXTERNALS, ...userExternals].filter(Boolean);
+	const detectedPinoTransports = /* @__PURE__ */ new Set();
+	logger.info("Analyzing dependencies...");
+	const allUsedExternals = /* @__PURE__ */ new Map();
+	const analyzeCache = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const analyzeResult = await analyzeEntry({
+			entry,
+			isVirtualFile: entry.includes("\n") || !(0, fs.existsSync)(entry)
+		}, mastraEntry, {
+			logger,
+			sourcemapEnabled: bundlerOptions?.enableSourcemap ?? false,
+			workspaceMap,
+			projectRoot,
+			shouldCheckTransitiveDependencies: true,
+			analyzeCache
+		});
+		(0, _babel_core.transformSync)(analyzeResult.output.code, {
+			filename: "pino-detection.js",
+			plugins: [() => detectPinoTransports(detectedPinoTransports)],
+			configFile: false,
+			babelrc: false,
+			code: false
+		});
+		await (0, fs_promises.writeFile)((0, path.join)(outputDir, `entry-${index++}.mjs`), analyzeResult.output.code);
+		for (const [dep, metadata] of analyzeResult.dependencies.entries()) {
+			if (allExternals.some((external) => require_utils.isDependencyPartOfPackage(dep, external)) || externalsPreset && !metadata.isWorkspace) {
+				const pkgName = require_utils.getPackageName(dep);
+				if (pkgName) allUsedExternals.set(pkgName, preferDependencyInfo(allUsedExternals.get(pkgName), metadata));
+				continue;
+			}
+			if (depsToOptimize.has(dep)) {
+				const existingEntry = depsToOptimize.get(dep);
+				depsToOptimize.set(dep, {
+					...existingEntry,
+					version: metadata.version ?? existingEntry.version,
+					packageSpec: metadata.packageSpec ?? existingEntry.packageSpec,
+					exports: [.../* @__PURE__ */ new Set([...existingEntry.exports, ...metadata.exports])]
+				});
+			} else depsToOptimize.set(dep, metadata);
+		}
+	}
+	const depsVersionInfo = /* @__PURE__ */ new Map();
+	for (const [dep, metadata] of depsToOptimize.entries()) {
+		const pkgName = require_utils.getPackageName(dep);
+		if (pkgName && (metadata.version || metadata.packageSpec)) depsVersionInfo.set(pkgName, preferDependencyInfo(depsVersionInfo.get(pkgName), metadata));
+		if (metadata.version || metadata.packageSpec) depsVersionInfo.set(dep, preferDependencyInfo(depsVersionInfo.get(dep), metadata));
+	}
+	/**
+	* Only during `mastra dev` we want to optimize workspace packages. In previous steps we might have added dependencies that are not workspace packages, so we gotta remove them again.
+	*/
+	if (isDev || externalsPreset) {
+		for (const [dep, metadata] of depsToOptimize.entries()) if (!metadata.isWorkspace) depsToOptimize.delete(dep);
+	}
+	const sortedDeps = Array.from(depsToOptimize.keys()).sort();
+	logger.info("Optimizing dependencies...");
+	logger.debug("Sorted dependencies", { deps: sortedDeps });
+	const { output, fileNameToDependencyMap, usedExternals } = await bundleExternals(depsToOptimize, outputDir, {
+		bundlerOptions: {
+			...bundlerOptions,
+			externals: bundlerOptions?.externals ?? allExternals,
+			isDev
+		},
+		projectRoot,
+		workspaceRoot,
+		workspaceMap,
+		platform
+	});
+	const relativeWorkspaceFolderPaths = Array.from(workspaceMap.values()).map((pkgInfo) => require_utils.slash((0, path.relative)(workspaceRoot || projectRoot, pkgInfo.location)));
+	for (const o of output) {
+		if (o.type === "asset") continue;
+		const importerId = getLastConcreteModuleId(o.moduleIds);
+		for (const i of o.imports) {
+			if (require_utils.isBuiltinModule(i)) continue;
+			if (i.startsWith(".") || i.startsWith("/")) continue;
+			if (!require_utils.isBareModuleSpecifier(i) || require_utils.isExternalProtocolImport(i)) continue;
+			if (relativeWorkspaceFolderPaths.some((workspacePath) => i.startsWith(workspacePath))) continue;
+			const pkgName = require_utils.getPackageName(i);
+			if (pkgName && workspaceMap.has(pkgName)) continue;
+			if (pkgName) {
+				const dependencyInfo = await resolveDependencyInfo(i, depsVersionInfo.get(i) || depsVersionInfo.get(pkgName), importerParentPaths(importerId, [projectRoot, ...Array.from(workspaceMap.values()).map((pkgInfo) => pkgInfo.location)]));
+				allUsedExternals.set(pkgName, preferDependencyInfo(allUsedExternals.get(pkgName), dependencyInfo));
+			}
+		}
+	}
+	const result = await validateOutput({
+		output,
+		reverseVirtualReferenceMap: fileNameToDependencyMap,
+		usedExternals,
+		outputDir,
+		projectRoot: workspaceRoot || projectRoot,
+		workspaceMap,
+		depsVersionInfo
+	}, logger);
+	/**
+	* Build the final set of external dependencies from four sources:
+	* 1. result.externalDependencies - externals discovered during bundle validation
+	* 2. allUsedExternals - packages detected via static analysis that matched the externals config
+	* 3. detectedPinoTransports - pino transports detected by the plugin during bundling
+	* 4. userDynamicPackages - user-specified packages loaded dynamically at runtime
+	*
+	* Prefer entries with version info over entries without
+	*/
+	const mergedExternalDeps = new Map(result.externalDependencies);
+	for (const [dep, info] of allUsedExternals) {
+		if (require_utils.isExternalProtocolImport(dep)) continue;
+		mergedExternalDeps.set(dep, preferDependencyInfo(mergedExternalDeps.get(dep), info));
+	}
+	const externalMetadataParentPaths = [
+		projectRoot,
+		...Array.from(workspaceMap.values()).map((pkgInfo) => pkgInfo.location),
+		__dirname
+	];
+	for (const [dep, info] of mergedExternalDeps) if (!info.version && !info.packageSpec) mergedExternalDeps.set(dep, await resolveDependencyInfo(dep, info, externalMetadataParentPaths));
+	for (const transport of detectedPinoTransports) if (!mergedExternalDeps.has(transport)) mergedExternalDeps.set(transport, await resolveDependencyInfo(transport, void 0, externalMetadataParentPaths));
+	for (const pkg of userDynamicPackages) if (!mergedExternalDeps.has(pkg)) mergedExternalDeps.set(pkg, await resolveDependencyInfo(pkg, void 0, externalMetadataParentPaths));
+	return {
+		...result,
+		externalDependencies: mergedExternalDeps,
+		...mastraConfigResult.projectType ? { projectType: mastraConfigResult.projectType } : {}
+	};
+}
+//#endregion
+Object.defineProperty(exports, "aliasHono", {
+	enumerable: true,
+	get: function() {
+		return aliasHono;
+	}
+});
+Object.defineProperty(exports, "analyzeBundle", {
+	enumerable: true,
+	get: function() {
+		return analyzeBundle;
+	}
+});
+Object.defineProperty(exports, "checkConfigExport", {
+	enumerable: true,
+	get: function() {
+		return checkConfigExport;
+	}
+});
+Object.defineProperty(exports, "getWorkspaceInformation", {
+	enumerable: true,
+	get: function() {
+		return getWorkspaceInformation;
+	}
+});
+
+//# sourceMappingURL=analyze-DhDZW9TS.cjs.map