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

package/dist/analyze-C2q7jxbN.js

@@ -0,0 +1,1308 @@
+import { a as getPackageName, c as isBuiltinModule, f as rollupSafeName, i as getNodeResolveOptions, l as isDependencyPartOfPackage, p as slash, r as getCompiledDepCachePath, s as isBareModuleSpecifier, u as isExternalProtocolImport } from "./utils-FVOUvj-I.js";
+import "./services-CLi56qqe.js";
+import { a as tsConfigPaths, c as protocolExternalResolver, d as getPackageRootPath, f as esmShim, i as mastraToolsAliasPlugin, o as subpathExternalsResolver, p as esbuild, r as mastraInternalAliasPlugin, s as removeDeployer, u as getPackageMetadata } from "./bundler-D86rFu2J.js";
+import { spawn } from "child_process";
+import { existsSync } from "fs";
+import { readFile, writeFile } from "fs/promises";
+import * as path$1 from "path";
+import { basename, dirname, isAbsolute, join, relative } from "path";
+import { ErrorCategory, ErrorDomain, MastraBaseError, MastraError } from "@mastra/core/error";
+import virtual from "@rollup/plugin-virtual";
+import * as pkg from "empathic/package";
+import { transformAsync, transformSync, types } from "@babel/core";
+import "@sindresorhus/slugify";
+import { createWorkspacesCache, findWorkspaces, findWorkspacesRoot } from "find-workspaces";
+import "fs-extra";
+import { fileURLToPath, pathToFileURL } from "url";
+import commonjs from "@rollup/plugin-commonjs";
+import json from "@rollup/plugin-json";
+import { rollup } from "rollup";
+import { optimizeLodashImports } from "@optimize-lodash/rollup-plugin";
+import nodeResolve from "@rollup/plugin-node-resolve";
+import { getPackageInfo } from "local-pkg";
+import { basename as basename$1 } from "path/posix";
+import * as resolve from "resolve.exports";
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+//#region src/bundler/workspaceDependencies.ts
+var import_stack_trace_parser_cjs = /* @__PURE__ */ __toESM((/* @__PURE__ */ __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;
+})))(), 1);
+/**
+* Create a shared cache for find-workspaces
+*/
+const workspacesCache = 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 = pkg.up({ cwd: dirname(mastraEntryFile) });
+	const location = closestPkgJson ? dirname(slash(closestPkgJson)) : slash(process.cwd());
+	const workspaces = await 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 ? 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$1(command, args = [], options = {}) {
+	return new Promise((resolve, reject) => {
+		let validationError = null;
+		const childProcess = 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$1(process.execPath, [
+		"--import",
+		import.meta.resolve("@mastra/deployer/loader"),
+		"--input-type=module",
+		"--enable-source-maps",
+		"-e",
+		`${prefixCode};import('${pathToFileURL(file).href}').catch(err => {
+        ${errorHandler.toString()}
+        errorHandler(err);
+      })`.replaceAll(/\n/g, "")
+	], {
+		env: {
+			...process.env,
+			MODULE_MAP: `${moduleResolveMapLocation}`,
+			STUBBED_EXTERNALS: JSON.stringify(stubbedExternals)
+		},
+		cwd: 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 = virtual({ "#entry": entry });
+		entry = "#entry";
+	}
+	const plugins = [];
+	if (virtualPlugin) plugins.push(virtualPlugin);
+	plugins.push(...[
+		protocolExternalResolver(),
+		mastraInternalAliasPlugin(mastraEntry),
+		mastraToolsAliasPlugin(),
+		tsConfigPaths(),
+		json(),
+		esbuild(),
+		commonjs({
+			strictRequires: "debug",
+			ignoreTryCatch: false,
+			transformMixedEsModules: true,
+			extensions: [".js", ".ts"]
+		}),
+		removeDeployer(mastraEntry, { sourcemap: sourcemapEnabled }),
+		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 getPackageRootPath(output.facadeModuleId) || projectRoot;
+	for (const [dependency, bindings] of Object.entries(output.importedBindings)) {
+		if (!isBareModuleSpecifier(dependency)) continue;
+		const pkgName = getPackageName(dependency);
+		let rootPath = null;
+		let isWorkspace = false;
+		let version;
+		let packageSpec;
+		if (pkgName) {
+			const metadata = await getPackageMetadata(dependency, entryRootPath);
+			rootPath = metadata.rootPath;
+			version = metadata.version;
+			packageSpec = metadata.packageSpec;
+			isWorkspace = workspaceMap.has(pkgName);
+		}
+		const normalizedRootPath = rootPath ? 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 = 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: 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) && isBareModuleSpecifier(dynamicImport)) {
+			const pkgName = getPackageName(dynamicImport);
+			let version;
+			let packageSpec;
+			let rootPath = null;
+			if (pkgName) {
+				const metadata = await getPackageMetadata(dynamicImport, entryRootPath);
+				rootPath = metadata.rootPath;
+				version = metadata.version;
+				packageSpec = metadata.packageSpec;
+			}
+			depsToOptimize.set(dynamicImport, {
+				exports: ["*"],
+				rootPath: rootPath ? 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 : slash(entry);
+	if (cacheKey && analyzeCache?.has(cacheKey)) return analyzeCache.get(cacheKey);
+	const optimizerBundler = await 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 fileURLToPath(import.meta.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 (isDependencyPartOfPackage(importedId, external)) importMap.set(external, info.id);
+		},
+		async generateBundle(options, bundle) {
+			const resolveMap = /* @__PURE__ */ new Map();
+			for (const [fileName, chunk] of Object.entries(bundle)) if (chunk.type === "chunk") {
+				for (const [external, resolvedFrom] of importMap) if (chunk.moduleIds.includes(resolvedFrom)) {
+					const fullPath = pathToFileURL(slash(join(projectRoot, fileName))).toString();
+					const innerMap = resolveMap.get(fullPath) || /* @__PURE__ */ new Map();
+					innerMap.set(external, pathToFileURL(slash(resolvedFrom)).toString());
+					resolveMap.set(fullPath, innerMap);
+				}
+			}
+			const resolveMapJson = Object.fromEntries(Array.from(resolveMap.entries()).map(([key, value]) => [key, Object.fromEntries(value.entries())]));
+			this.emitFile({
+				type: "asset",
+				name: "module-resolve-map.json",
+				source: `${JSON.stringify(resolveMapJson, null, 2)}`
+			});
+		}
+	};
+}
+//#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, 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 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$1.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(getCompiledDepCachePath(rootPath, basename$1(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 getPackageRootPath(pkg);
+		if (dir) transpilePackagesMap.set(pkg, slash(dir));
+		else transpilePackagesMap.set(pkg, workspaceMap.get(pkg)?.location ?? pkg);
+	}
+	return [
+		virtual(Array.from(virtualDependencies.entries()).reduce((acc, [dep, virtualDep]) => {
+			acc[`#virtual-${dep}`] = virtualDep.virtual;
+			return acc;
+		}, {})),
+		tsConfigPaths(),
+		protocolExternalResolver(),
+		subpathExternalsResolver(externals),
+		transpilePackagesMap.size ? esbuild({
+			format: "esm",
+			include: [...[...transpilePackagesMap.values()].map((p) => {
+				if (path$1.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$1.join(rootDir, path$1.dirname(path$1.dirname(path$1.dirname(info.name))));
+				const pkgJsonBuffer = await readFile(path$1.join(packageRootPath, "package.json"), "utf-8");
+				const pkgJson = JSON.parse(pkgJsonBuffer);
+				if (!pkgJson) return null;
+				const pkgName = pkgJson.name || "";
+				let resolvedPath = resolve.exports(pkgJson, id.replace(pkgName, "."))?.[0];
+				if (!resolvedPath) resolvedPath = pkgJson.main ?? "index.js";
+				return await this.resolve(path$1.posix.join(packageRootPath, resolvedPath), importer, options);
+			}
+		} : null,
+		optimizeLodashImports({ include: "**/*.{js,ts,mjs,cjs}" }),
+		commonjs({
+			strictRequires: "strict",
+			transformMixedEsModules: true,
+			ignoreTryCatch: false
+		}),
+		bundlerOptions.noBundling ? null : nodeResolve(getNodeResolveOptions(platform)),
+		bundlerOptions.noBundling ? esmShim() : null,
+		aliasHono(),
+		json(),
+		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 getPackageInfo(importer))?.packageJson?.name || id;
+					throw new MastraBaseError({
+						id: "DEPLOYER_BUNDLE_EXTERNALS_MISSING_NATIVE_BUILD",
+						domain: ErrorDomain.DEPLOYER,
+						category: 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 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 = slash(moduleId);
+					for (const [pkgName, pkgInfo] of workspaceMap.entries()) {
+						const location = slash(pkgInfo.location);
+						if (normalized.startsWith(location)) {
+							importedFromPackages.add(pkgName);
+							break;
+						}
+					}
+				}
+				if (importedFromPackages.size > 1) throw new MastraBaseError({
+					id: "DEPLOYER_BUNDLE_EXTERNALS_SHARED_CHUNK",
+					domain: ErrorDomain.DEPLOYER,
+					category: 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(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 (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$1.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$1.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 (!types.isIdentifier(path.node.callee)) return;
+			const binding = path.scope.getBinding(path.node.callee.name);
+			if (binding?.path.isImportSpecifier() && types.isIdentifier(binding.path.node.imported, { name: "MastraFactory" })) result.projectType = "factory";
+		},
+		ExportNamedDeclaration(path) {
+			const decl = path.node.declaration;
+			if (types.isVariableDeclaration(decl)) {
+				const varDecl = decl.declarations[0];
+				if (types.isIdentifier(varDecl?.id, { name: "mastra" }) && types.isNewExpression(varDecl.init) && 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 (types.isExportSpecifier(spec) && types.isIdentifier(spec.exported, { name: "mastra" }) && types.isIdentifier(spec.local) && mastraVars.has(spec.local.name)) result.hasValidConfig = true;
+			}
+		},
+		VariableDeclaration(path) {
+			for (const decl of path.node.declarations) if (types.isIdentifier(decl.id) && types.isNewExpression(decl.init) && 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 (types.isStringLiteral(node)) return node.value;
+	if (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 (!types.isObjectProperty(prop)) return null;
+	const key = prop.key;
+	if (types.isIdentifier(key, { name: "target" }) || 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 (types.isIdentifier(imported) && imported.name === "default") return true;
+			if (types.isStringLiteral(imported) && imported.value === "default") return true;
+		}
+		return false;
+	}
+	if (bindingPath.isVariableDeclarator()) {
+		const init = bindingPath.node.init;
+		if (types.isCallExpression(init) && types.isIdentifier(init.callee, { name: "require" }) && init.arguments.length === 1 && 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 (!types.isMemberExpression(callee)) return false;
+	if (!types.isIdentifier(callee.property, { name: "transport" })) return false;
+	if (types.isIdentifier(callee.object)) return isBindingFromPino(path, callee.object.name);
+	if (types.isMemberExpression(callee.object) && types.isIdentifier(callee.object.object) && 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 (!types.isObjectExpression(arg)) return targets;
+	for (const prop of arg.properties) {
+		if (!types.isObjectProperty(prop)) continue;
+		const key = prop.key;
+		const keyName = types.isIdentifier(key) ? key.name : types.isStringLiteral(key) ? key.value : null;
+		if (keyName === "target") {
+			const value = getStringValue(prop.value);
+			if (value) targets.push(value);
+		} else if (keyName === "targets") {
+			if (types.isArrayExpression(prop.value)) {
+				for (const element of prop.value.elements) if (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 && !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 = getPackageName(dep);
+	const packageNames = [...new Set([dep, packageName].filter(Boolean))];
+	for (const parentPath of parentPaths) for (const name of packageNames) {
+		const metadata = await getPackageMetadata(name, parentPath);
+		if (metadata.version || metadata.packageSpec) return preferDependencyInfo(existing, metadata);
+	}
+	for (const name of packageNames) {
+		const metadata = await getPackageMetadata(name);
+		if (metadata.version || metadata.packageSpec) return preferDependencyInfo(existing, metadata);
+	}
+	return existing ?? {};
+}
+function importerParentPaths(importerId, base) {
+	if (!importerId || importerId.startsWith("\0") || !isAbsolute(importerId)) return base;
+	return [.../* @__PURE__ */ new Set([importerId, ...base])];
+}
+function getLastConcreteModuleId(moduleIds) {
+	return moduleIds.findLast((id) => !id.startsWith("\0") && isAbsolute(id));
+}
+function throwExternalDependencyError({ errorId, moduleName, packageName, messagePrefix }) {
+	throw new MastraError({
+		id: errorId,
+		domain: ErrorDomain.DEPLOYER,
+		category: 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(basename(file.name));
+			else moduleName = getPackageNameFromBundledModuleName(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(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(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 MastraError({
+		id: "DEPLOYER_ANALYZE_ERROR_IN_WORKSPACE",
+		domain: ErrorDomain.DEPLOYER,
+		category: 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(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(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 (isExternalProtocolImport(dep)) continue;
+		const pkgName = 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 (existsSync(join(outputDir, "binary-map.json"))) {
+		const binaryMap = await readFile(join(outputDir, "binary-map.json"), "utf-8");
+		binaryMapData = JSON.parse(binaryMap);
+	}
+	for (const file of output) {
+		if (file.type === "asset") continue;
+		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: 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 readFile(mastraEntry, "utf-8");
+	const mastraConfigResult = { hasValidConfig: false };
+	await transformAsync(mastraConfig, {
+		filename: mastraEntry,
+		presets: [import.meta.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") || !existsSync(entry)
+		}, mastraEntry, {
+			logger,
+			sourcemapEnabled: bundlerOptions?.enableSourcemap ?? false,
+			workspaceMap,
+			projectRoot,
+			shouldCheckTransitiveDependencies: true,
+			analyzeCache
+		});
+		transformSync(analyzeResult.output.code, {
+			filename: "pino-detection.js",
+			plugins: [() => detectPinoTransports(detectedPinoTransports)],
+			configFile: false,
+			babelrc: false,
+			code: false
+		});
+		await writeFile(join(outputDir, `entry-${index++}.mjs`), analyzeResult.output.code);
+		for (const [dep, metadata] of analyzeResult.dependencies.entries()) {
+			if (allExternals.some((external) => isDependencyPartOfPackage(dep, external)) || externalsPreset && !metadata.isWorkspace) {
+				const pkgName = 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 = 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) => slash(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 (isBuiltinModule(i)) continue;
+			if (i.startsWith(".") || i.startsWith("/")) continue;
+			if (!isBareModuleSpecifier(i) || isExternalProtocolImport(i)) continue;
+			if (relativeWorkspaceFolderPaths.some((workspacePath) => i.startsWith(workspacePath))) continue;
+			const pkgName = 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 (isExternalProtocolImport(dep)) continue;
+		mergedExternalDeps.set(dep, preferDependencyInfo(mergedExternalDeps.get(dep), info));
+	}
+	const externalMetadataParentPaths = [
+		projectRoot,
+		...Array.from(workspaceMap.values()).map((pkgInfo) => pkgInfo.location),
+		import.meta.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
+export { getWorkspaceInformation as i, checkConfigExport as n, aliasHono as r, analyzeBundle as t };
+
+//# sourceMappingURL=analyze-C2q7jxbN.js.map