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

package/dist/bundler-BqrDXofn.cjs

@@ -0,0 +1,792 @@
+const require_rolldown_runtime = require("./rolldown-runtime-emK7D4bc.cjs");
+const require_utils = require("./utils-O98BGdnP.cjs");
+let fs = require("fs");
+fs = require_rolldown_runtime.__toESM(fs, 1);
+let fs_promises = require("fs/promises");
+let path = require("path");
+path = require_rolldown_runtime.__toESM(path, 1);
+let fs_extra_esm = require("fs-extra/esm");
+let _babel_core = require("@babel/core");
+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_alias = require("@rollup/plugin-alias");
+_rollup_plugin_alias = require_rolldown_runtime.__toESM(_rollup_plugin_alias, 1);
+let _rollup_plugin_node_resolve = require("@rollup/plugin-node-resolve");
+_rollup_plugin_node_resolve = require_rolldown_runtime.__toESM(_rollup_plugin_node_resolve, 1);
+let rollup_plugin_esbuild = require("rollup-plugin-esbuild");
+rollup_plugin_esbuild = require_rolldown_runtime.__toESM(rollup_plugin_esbuild, 1);
+let _rollup_plugin_esm_shim = require("@rollup/plugin-esm-shim");
+_rollup_plugin_esm_shim = require_rolldown_runtime.__toESM(_rollup_plugin_esm_shim, 1);
+let local_pkg = require("local-pkg");
+let strip_json_comments = require("strip-json-comments");
+strip_json_comments = require_rolldown_runtime.__toESM(strip_json_comments, 1);
+let typescript_paths = require("typescript-paths");
+//#region src/build/plugins/esbuild.ts
+function esbuild(options = {}) {
+	return (0, rollup_plugin_esbuild.default)({
+		target: "node20",
+		platform: "node",
+		minify: false,
+		...options
+	});
+}
+//#endregion
+//#region src/build/plugins/esm-shim.ts
+const FilenameDeclarationRegex = /(?:const|let|var)\s+__filename/;
+const DirnameDeclarationRegex = /(?:const|let|var)\s+__dirname/;
+/**
+* Custom ESM shim plugin wrapper that respects user-declared __filename/__dirname variables.
+*
+* The original @rollup/plugin-esm-shim would inject shims even when users had already declared
+* their own __filename/__dirname, causing "Identifier '__filename' has already been declared" errors.
+*
+* This wrapper checks if the user has already declared these variables and skips the shim injection
+* if so. If either variable is declared, we skip the shim entirely since the original plugin injects
+* both together and we assume users who declare one will also handle the other if needed.
+*/
+function esmShim() {
+	const original = (0, _rollup_plugin_esm_shim.default)();
+	return {
+		name: "esm-shim",
+		renderChunk(code, chunk, opts, meta) {
+			const hasFilename = code.includes("__filename");
+			const hasDirname = code.includes("__dirname");
+			const userDeclaredFilename = hasFilename && FilenameDeclarationRegex.test(code);
+			const userDeclaredDirname = hasDirname && DirnameDeclarationRegex.test(code);
+			if (userDeclaredFilename || userDeclaredDirname) return null;
+			if (typeof original.renderChunk === "function") return original.renderChunk.call(this, code, chunk, opts, meta);
+			return null;
+		}
+	};
+}
+//#endregion
+//#region src/build/plugins/local-storage-detector.ts
+/**
+* Connection-string-shaped patterns that resolve to the build host and will
+* never work inside the deploy container.
+*/
+const LOCAL_HOST_PATTERNS = [
+	{
+		pattern: /\bfile:\.{1,2}\/[^\s'"`]+\.(?:db|sqlite)\b/gi,
+		hint: "LibSQL/SQLite file path relative to the build host"
+	},
+	{
+		pattern: /\b(?:postgres(?:ql)?|mysql|mongodb|redis|libsql):\/\/[^/\s'"`]*localhost\b/gi,
+		hint: "localhost in a connection string"
+	},
+	{
+		pattern: /\b(?:postgres(?:ql)?|mysql|mongodb|redis|libsql):\/\/[^/\s'"`]*127\.0\.0\.1\b/g,
+		hint: "127.0.0.1 in a connection string"
+	}
+];
+/**
+* Everything under `.mastra/.build/` is deployer-generated pre-bundled
+* dependency code (`@mastra__*.mjs` shims and their shared `chunk-*.mjs`
+* files), never user-authored. These preserve JSDoc examples from the
+* original library source (e.g. `LibSQLStore({ url: 'file:./data.db' })`)
+* which would otherwise trip the host-local detector, and their env var
+* reads are library refs that must not count as user references.
+*/
+const MASTRA_BUILD_DIR = /[\\/]\.mastra[\\/]\.build[\\/]/;
+const PROCESS_ENV_DOT = /\bprocess\.env\.([A-Z_][A-Z0-9_]*)\b/g;
+const PROCESS_ENV_BRACKET = /\bprocess\.env\[['"]([A-Z_][A-Z0-9_]*)['"]\]/g;
+/** Names of the metadata assets emitted into the output dir. */
+const LEGACY_LOCAL_PATHS_FILE = "preflight-local-paths.json";
+const PREFLIGHT_METADATA_FILE = "preflight-metadata.json";
+function collectEnvRefs(code) {
+	const refs = /* @__PURE__ */ new Set();
+	for (const m of code.matchAll(PROCESS_ENV_DOT)) refs.add(m[1]);
+	for (const m of code.matchAll(PROCESS_ENV_BRACKET)) refs.add(m[1]);
+	return refs;
+}
+function isAstNode(v) {
+	return typeof v === "object" && v !== null && typeof v.type === "string";
+}
+function walkAst(node, visit) {
+	visit(node);
+	for (const value of Object.values(node)) if (Array.isArray(value)) {
+		for (const item of value) if (isAstNode(item)) walkAst(item, visit);
+	} else if (isAstNode(value)) walkAst(value, visit);
+}
+/** Find the first `process.env.X` / `process.env['X']` read inside an expression. */
+function findFirstEnvRef(node) {
+	let found;
+	walkAst(node, (n) => {
+		if (found !== void 0) return;
+		if (n.type !== "MemberExpression") return;
+		const object = n.object;
+		if (!object || object.type !== "MemberExpression" || object.object?.type !== "Identifier" || object.object.name !== "process" || object.property?.type !== "Identifier" || object.property.name !== "env") return;
+		const property = n.property;
+		if (property?.type === "Identifier" && !n.computed) found = property.name;
+		else if (property?.type === "Literal" && typeof property.value === "string") found = property.value;
+	});
+	return found;
+}
+/**
+* Parse a module and figure out, for each detected local-path value, whether
+* every string literal containing it is the fallback arm of a
+* `process.env.X || <literal>` / `??` expression. Returns a map from
+* detected value to guarding env var name. Values with any unguarded
+* occurrence (or inconsistent guards) are absent — the CLI then errors as
+* before, which is the safe default.
+*/
+function findGuardedValues(ast, values) {
+	const stringLiterals = [];
+	const guardedLiterals = /* @__PURE__ */ new Map();
+	walkAst(ast, (node) => {
+		if (node.type === "Literal" && typeof node.value === "string") {
+			stringLiterals.push(node);
+			return;
+		}
+		if (node.type === "LogicalExpression" && (node.operator === "||" || node.operator === "??")) {
+			const right = node.right;
+			if (right?.type === "Literal" && typeof right.value === "string") {
+				const envName = findFirstEnvRef(node.left);
+				if (envName) guardedLiterals.set(right, envName);
+			}
+		}
+	});
+	const result = /* @__PURE__ */ new Map();
+	for (const value of values) {
+		const containing = stringLiterals.filter((lit) => lit.value.includes(value));
+		if (containing.length === 0) continue;
+		const guards = containing.map((lit) => guardedLiterals.get(lit));
+		const first = guards[0];
+		if (first !== void 0 && guards.every((g) => g === first)) result.set(value, first);
+	}
+	return result;
+}
+/**
+* Rollup plugin that detects host-local storage URLs (e.g. `file:./mastra.db`,
+* `postgres://localhost`) in **user source modules** during bundling, and
+* collects the env vars user code reads via `process.env.X`.
+*
+* Only modules outside `node_modules` (and the deployer's own
+* `.mastra/.build/` pre-bundled files) are inspected, so library code
+* (like Agent Builder prompt templates or JSDoc examples in `@mastra/core`)
+* is naturally excluded.  When `rootDir` is given, modules outside it are
+* also excluded — symlinked dependencies (pnpm `link:`/`file:`) resolve to
+* real paths that never contain `node_modules`.  Tree-shaken modules are
+* excluded via
+* `generateBundle` — only modules that actually contribute rendered code to
+* the output are reported.
+*
+* When a detected literal is the fallback arm of a `process.env.X || literal`
+* expression, `guardedBy: "X"` is recorded so the CLI preflight can apply
+* deploy-time env context instead of hard-erroring on a dead fallback.
+*
+* Two assets are emitted into the output directory for the CLI preflight:
+* - `preflight-metadata.json` — unified metadata (local paths + user env refs)
+* - `preflight-local-paths.json` — legacy shape, kept for one release so an
+*   older globally-installed CLI paired with a newer project-local deployer
+*   doesn't lose the LOCAL_STORAGE_PATH check.
+*/
+function localStorageDetector(rootDir) {
+	const userModuleMatches = /* @__PURE__ */ new Map();
+	const userModuleEnvRefs = /* @__PURE__ */ new Map();
+	let normalizedRoot;
+	if (rootDir) {
+		let root = rootDir.replace(/\\/g, "/");
+		while (root.endsWith("/")) root = root.slice(0, -1);
+		normalizedRoot = root + "/";
+	}
+	return {
+		name: "mastra-local-storage-detector",
+		transform(_code, id) {
+			if (id.includes("node_modules")) return null;
+			if (MASTRA_BUILD_DIR.test(id)) return null;
+			if (normalizedRoot && !id.replace(/\\/g, "/").startsWith(normalizedRoot)) return null;
+			const refs = collectEnvRefs(_code);
+			if (refs.size > 0) userModuleEnvRefs.set(id, refs);
+			const matches = [];
+			for (const { pattern, hint } of LOCAL_HOST_PATTERNS) {
+				const re = new RegExp(pattern.source, pattern.flags.includes("g") ? pattern.flags : pattern.flags + "g");
+				for (const m of _code.matchAll(re)) matches.push({
+					value: m[0],
+					hint
+				});
+			}
+			if (matches.length > 0) {
+				try {
+					const guarded = findGuardedValues(this.parse(_code), new Set(matches.map((m) => m.value)));
+					for (const match of matches) {
+						const guardedBy = guarded.get(match.value);
+						if (guardedBy) match.guardedBy = guardedBy;
+					}
+				} catch {}
+				userModuleMatches.set(id, matches);
+			}
+			return null;
+		},
+		generateBundle(_, bundle) {
+			const detections = [];
+			const seen = /* @__PURE__ */ new Set();
+			const userEnvRefs = /* @__PURE__ */ new Set();
+			for (const chunk of Object.values(bundle)) {
+				if (chunk.type !== "chunk") continue;
+				for (const [moduleId, moduleInfo] of Object.entries(chunk.modules)) {
+					if (moduleInfo.renderedLength === 0) continue;
+					for (const ref of userModuleEnvRefs.get(moduleId) ?? []) userEnvRefs.add(ref);
+					const matches = userModuleMatches.get(moduleId);
+					if (!matches) continue;
+					for (const { value, hint, guardedBy } of matches) {
+						const key = `${hint}::${value}`;
+						if (seen.has(key)) continue;
+						seen.add(key);
+						detections.push({
+							value,
+							hint,
+							module: moduleId,
+							...guardedBy ? { guardedBy } : {}
+						});
+					}
+				}
+			}
+			const metadata = {
+				version: 1,
+				localPaths: detections,
+				userEnvRefs: [...userEnvRefs].sort()
+			};
+			this.emitFile({
+				type: "asset",
+				fileName: PREFLIGHT_METADATA_FILE,
+				source: JSON.stringify(metadata)
+			});
+			this.emitFile({
+				type: "asset",
+				fileName: LEGACY_LOCAL_PATHS_FILE,
+				source: JSON.stringify(detections.map(({ value, hint, module }) => ({
+					value,
+					hint,
+					module
+				})))
+			});
+		}
+	};
+}
+//#endregion
+//#region src/build/package-info.ts
+/**
+* Note: This function depends on local-pkg and should only be used at build-time.
+* It is in a separate file to avoid including local-pkg in runtime code.
+*/
+/**
+* Normalize a resolution base path to a directory file URL.
+*
+* Callers often pass a module file path (e.g. a rollup module id like
+* `node_modules/@mastra/core/dist/chunk-XYZ.js`) as the parent path. mlly (used by local-pkg)
+* also treats each resolution base as a directory candidate (`<base>/_index.js`), which makes it
+* try to read `<file>/package.json`. That fails with ENOTDIR, which mlly does not tolerate
+* (only ENOENT) and local-pkg then logs the raw error to the console. Using the file's directory
+* as the base avoids this while resolving identically.
+*/
+function toParentDirectoryUrl(parentPath) {
+	let fsPath = parentPath.startsWith("file://") ? (0, url.fileURLToPath)(parentPath) : parentPath;
+	try {
+		if ((0, fs.statSync)(fsPath).isFile()) fsPath = (0, path.dirname)(fsPath);
+	} catch {}
+	return (0, url.pathToFileURL)(fsPath).href;
+}
+/**
+* Get package root path
+*/
+async function getPackageRootPath(packageName, parentPath) {
+	let rootPath;
+	try {
+		let options = void 0;
+		if (parentPath) options = { paths: [toParentDirectoryUrl(parentPath)] };
+		rootPath = (await (0, local_pkg.getPackageInfo)(packageName, options))?.rootPath ?? null;
+	} catch {
+		rootPath = null;
+	}
+	return rootPath;
+}
+async function readPackageMetadata(rootPath, requestedPackageName) {
+	try {
+		const pkgJson = await (0, fs_extra_esm.readJSON)(`${rootPath}/package.json`);
+		const version = pkgJson.version;
+		const actualPackageName = pkgJson.name;
+		return {
+			rootPath,
+			version,
+			packageSpec: version && actualPackageName && requestedPackageName && requestedPackageName !== actualPackageName ? `npm:${actualPackageName}@${version}` : void 0
+		};
+	} catch {
+		return { rootPath };
+	}
+}
+async function getPackageMetadata(packageName, parentPath) {
+	const requestedPackageName = require_utils.getPackageName(packageName);
+	const packageNames = [...new Set([packageName, requestedPackageName].filter(Boolean))];
+	let firstRootPath = null;
+	for (const name of packageNames) {
+		const rootPath = await getPackageRootPath(name, parentPath);
+		firstRootPath ??= rootPath;
+		if (!rootPath) continue;
+		const metadata = await readPackageMetadata(rootPath, requestedPackageName ?? null);
+		if (metadata.version || metadata.packageSpec) return metadata;
+	}
+	return { rootPath: firstRootPath };
+}
+//#endregion
+//#region src/build/plugins/node-modules-extension-resolver.ts
+/**
+* Check if a package has an exports field in its package.json.
+* Results are cached to avoid repeated filesystem reads.
+*/
+async function getPackageJSON(pkgName, importer) {
+	const pkgRoot = await getPackageRootPath(pkgName, importer);
+	if (!pkgRoot) throw new Error(`Package ${pkgName} not found`);
+	return JSON.parse(await (0, fs_promises.readFile)((0, path.join)(pkgRoot, "package.json"), "utf-8"));
+}
+/**
+* Rollup plugin that resolves module extensions for external dependencies.
+*
+* This plugin handles ESM compatibility for external imports when node-resolve is not used:
+* - Packages WITH exports field (e.g., hono, date-fns): Keep imports as-is or strip redundant extensions
+* - Packages WITHOUT exports field (e.g., lodash): Add .js extension for direct file imports
+*/
+function nodeModulesExtensionResolver() {
+	const nodeResolvePlugin = (0, _rollup_plugin_node_resolve.default)();
+	return {
+		name: "node-modules-extension-resolver",
+		async resolveId(id, importer, options) {
+			if (!importer || !require_utils.isBareModuleSpecifier(id) || require_utils.isExternalProtocolImport(id) || (0, path.isAbsolute)(id)) return null;
+			const parts = id.split("/");
+			const isScoped = id.startsWith("@");
+			if (isScoped && parts.length === 2 || !isScoped && parts.length === 1) return null;
+			const pkgName = require_utils.getPackageName(id);
+			if (!pkgName) return null;
+			try {
+				if (!!(await getPackageJSON(pkgName, importer)).exports) return null;
+				const packageRoot = await getPackageRootPath(pkgName, importer);
+				const nodeResolved = await nodeResolvePlugin.resolveId?.handler?.call(this, id, importer, options);
+				if (!nodeResolved?.id) return null;
+				let filePath = nodeResolved.id;
+				if (nodeResolved.resolvedBy === "commonjs--resolver") filePath = filePath.substring(1).split("?")[0];
+				return {
+					id: filePath.replace(packageRoot, pkgName),
+					external: true
+				};
+			} catch (err) {
+				console.error(err);
+				return null;
+			}
+		}
+	};
+}
+//#endregion
+//#region src/build/plugins/protocol-external-resolver.ts
+function protocolExternalResolver({ exclude = ["node:"] } = {}) {
+	return {
+		name: "protocol-external-resolver",
+		resolveId(id) {
+			if (!require_utils.isExternalProtocolImport(id, exclude)) return null;
+			return {
+				id,
+				external: true
+			};
+		}
+	};
+}
+//#endregion
+//#region src/build/babel/remove-deployer.ts
+function removeDeployer$1() {
+	function removeDeployerFromObject(objectExpr, scope) {
+		const deployerProp = objectExpr.properties.find((prop) => _babel_core.types.isObjectProperty(prop) && _babel_core.types.isIdentifier(prop.key) && prop.key.name === "deployer");
+		if (deployerProp) {
+			objectExpr.properties = objectExpr.properties.filter((prop) => prop !== deployerProp);
+			if (_babel_core.types.isIdentifier(deployerProp.value)) {
+				const deployerBinding = scope.getBinding(deployerProp.value.name);
+				if (deployerBinding) deployerBinding.path?.parentPath?.remove();
+			}
+		}
+		return deployerProp;
+	}
+	return {
+		name: "remove-deployer",
+		visitor: { NewExpression(path, state) {
+			if (!path.findParent((path) => _babel_core.types.isVariableDeclarator(path.node))) return;
+			const parentNode = path.parentPath.node;
+			if (!_babel_core.types.isVariableDeclarator(parentNode) || !_babel_core.types.isIdentifier(parentNode.id) || parentNode.id.name !== "mastra") return;
+			if (!state.hasReplaced) {
+				state.hasReplaced = true;
+				const newMastraObj = _babel_core.types.cloneNode(path.node);
+				if (_babel_core.types.isObjectExpression(newMastraObj.arguments[0]) && newMastraObj.arguments[0].properties?.length) {
+					const objectArg = newMastraObj.arguments[0];
+					let foundDeployer = false;
+					if (removeDeployerFromObject(objectArg, state.file.scope)) foundDeployer = true;
+					for (const prop of objectArg.properties) if (_babel_core.types.isSpreadElement(prop) && _babel_core.types.isIdentifier(prop.argument)) {
+						const spreadBinding = state.file.scope.getBinding(prop.argument.name);
+						if (spreadBinding?.path && _babel_core.types.isVariableDeclarator(spreadBinding.path.node)) {
+							const init = spreadBinding.path.node.init;
+							if (_babel_core.types.isObjectExpression(init)) {
+								if (removeDeployerFromObject(init, state.file.scope)) foundDeployer = true;
+							}
+						}
+					}
+					if (foundDeployer) path.replaceWith(newMastraObj);
+				}
+			}
+		} }
+	};
+}
+//#endregion
+//#region src/build/plugins/remove-deployer.ts
+function removeDeployer(mastraEntry, options) {
+	return {
+		name: "remove-deployer",
+		transform(code, id) {
+			if (id !== mastraEntry) return;
+			return (0, _babel_core.transformAsync)(code, {
+				babelrc: false,
+				configFile: false,
+				filename: id,
+				plugins: [removeDeployer$1],
+				sourceMaps: options?.sourcemap
+			}).then((result) => ({
+				code: result.code,
+				map: result.map
+			}));
+		}
+	};
+}
+//#endregion
+//#region src/build/plugins/subpath-externals-resolver.ts
+function subpathExternalsResolver(externals) {
+	return {
+		name: "subpath-externals-resolver",
+		resolveId(id) {
+			if (id.startsWith(".") || id.startsWith("/")) return null;
+			if (externals.some((external) => require_utils.isDependencyPartOfPackage(id, external))) return {
+				id,
+				external: true
+			};
+		}
+	};
+}
+//#endregion
+//#region src/build/plugins/tsconfig-paths.ts
+const PLUGIN_NAME = "tsconfig-paths";
+const JS_IMPORT_SOURCE_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".js",
+	".jsx"
+];
+/**
+* Check if a tsconfig file has path mappings configured.
+* Exported for testing purposes.
+*
+* @param tsConfigPath - Path to the tsconfig.json file
+* @returns true if the tsconfig has paths configured or extends another config, false otherwise
+*/
+function hasPaths(tsConfigPath) {
+	try {
+		const content = fs.default.readFileSync(tsConfigPath, "utf8");
+		const config = JSON.parse((0, strip_json_comments.default)(content));
+		return !!(config.compilerOptions?.paths && Object.keys(config.compilerOptions.paths).length > 0 || typeof config.extends === "string" && config.extends.length > 0 || Array.isArray(config.extends) && config.extends.length > 0);
+	} catch {
+		return false;
+	}
+}
+function tsConfigPaths({ tsConfigPath, respectCoreModule, localResolve } = {}) {
+	const handlerCache = /* @__PURE__ */ new Map();
+	function resolveJsImportToSourceFile(moduleName) {
+		if (fs.default.existsSync(moduleName)) return moduleName;
+		const parsed = path.default.parse(moduleName);
+		if (parsed.ext !== ".js") return moduleName;
+		for (const extension of JS_IMPORT_SOURCE_EXTENSIONS) {
+			const candidate = path.default.join(parsed.dir, `${parsed.name}${extension}`);
+			if (fs.default.existsSync(candidate)) return candidate;
+		}
+		return moduleName;
+	}
+	function findTsConfigForFile(filePath) {
+		let currentDir = path.default.dirname(filePath);
+		const root = path.default.parse(currentDir).root;
+		while (currentDir !== root) {
+			const tsConfigPath = path.default.join(currentDir, "tsconfig.json");
+			if (fs.default.existsSync(tsConfigPath)) {
+				if (hasPaths(tsConfigPath)) return tsConfigPath;
+			}
+			const tsConfigBasePath = path.default.join(currentDir, "tsconfig.base.json");
+			if (fs.default.existsSync(tsConfigBasePath)) {
+				if (hasPaths(tsConfigBasePath)) return tsConfigBasePath;
+			}
+			currentDir = path.default.dirname(currentDir);
+		}
+		return null;
+	}
+	function getHandlerForFile(filePath) {
+		if (tsConfigPath && typeof tsConfigPath === "string") {
+			if (!handlerCache.has(tsConfigPath)) handlerCache.set(tsConfigPath, (0, typescript_paths.createHandler)({
+				log: () => {},
+				tsConfigPath,
+				respectCoreModule,
+				falllback: (moduleName) => fs.default.existsSync(moduleName)
+			}));
+			return handlerCache.get(tsConfigPath);
+		}
+		const configPath = findTsConfigForFile(filePath);
+		if (!configPath) return null;
+		if (!handlerCache.has(configPath)) handlerCache.set(configPath, (0, typescript_paths.createHandler)({
+			log: () => {},
+			tsConfigPath: configPath,
+			respectCoreModule,
+			falllback: (moduleName) => fs.default.existsSync(moduleName)
+		}));
+		return handlerCache.get(configPath);
+	}
+	function resolveAlias(request, importer) {
+		const dynamicHandler = getHandlerForFile(importer);
+		if (!dynamicHandler) return null;
+		return dynamicHandler(request, (0, path.normalize)(importer));
+	}
+	return {
+		name: PLUGIN_NAME,
+		resolveId: {
+			order: "pre",
+			async handler(request, importer, options) {
+				if (!importer || request.startsWith("\0") || importer.charCodeAt(0) === 0) return null;
+				if (!path.default.isAbsolute(importer)) importer = path.default.resolve(process.cwd(), importer);
+				const moduleName = resolveAlias(request, importer);
+				if (!moduleName) {
+					const resolved = await this.resolve(request, importer, {
+						skipSelf: true,
+						...options
+					});
+					if (!resolved) return null;
+					if (localResolve) {
+						const importerPluginMeta = this.getModuleInfo(importer)?.meta?.[PLUGIN_NAME];
+						if (!request.startsWith("./") && !request.startsWith("../") && importerPluginMeta?.resolved) return {
+							...resolved,
+							external: !request.startsWith("hono/") && request !== "hono"
+						};
+					}
+					return {
+						...resolved,
+						meta: { ...resolved.meta || {} }
+					};
+				}
+				const resolvedModuleName = resolveJsImportToSourceFile(moduleName);
+				if (!path.default.extname(resolvedModuleName)) {
+					const resolved = await this.resolve(resolvedModuleName, importer, {
+						skipSelf: true,
+						...options
+					});
+					if (!resolved) return null;
+					return {
+						...resolved,
+						meta: {
+							...resolved.meta,
+							[PLUGIN_NAME]: { resolved: true }
+						}
+					};
+				}
+				const resolved = await this.resolve(resolvedModuleName, importer, {
+					skipSelf: true,
+					...options
+				});
+				if (!resolved) return null;
+				return {
+					...resolved,
+					meta: {
+						...resolved.meta,
+						[PLUGIN_NAME]: { resolved: true }
+					}
+				};
+			}
+		}
+	};
+}
+//#endregion
+//#region src/build/bundler.ts
+function mastraInternalAliasPlugin(entryFile) {
+	const normalizedEntryFile = require_utils.slash(entryFile);
+	return (0, _rollup_plugin_alias.default)({ entries: [
+		{
+			find: /^\#server$/,
+			replacement: require_utils.slash((0, url.fileURLToPath)({}.resolve("@mastra/deployer/server")))
+		},
+		{
+			find: /^\@mastra\/server\/(.*)/,
+			replacement: `@mastra/server/$1`,
+			customResolver: (id) => {
+				if (id.startsWith("@mastra/server")) return { id: (0, url.fileURLToPath)({}.resolve(id)) };
+			}
+		},
+		{
+			find: /^\#mastra$/,
+			replacement: normalizedEntryFile
+		}
+	] });
+}
+function mastraToolsAliasPlugin() {
+	return {
+		name: "tools-rewriter",
+		resolveId(id) {
+			if (id === "#tools") return {
+				id: "./tools.mjs",
+				external: true
+			};
+		}
+	};
+}
+async function getInputOptions(entryFile, analyzedBundleInfo, platform, env = { "process.env.NODE_ENV": JSON.stringify("production") }, { sourcemap = false, isDev = false, projectRoot, workspaceRoot = void 0, enableEsmShim = true, externalsPreset = false }) {
+	const nodeResolvePlugin = (0, _rollup_plugin_node_resolve.default)(require_utils.getNodeResolveOptions(platform));
+	const externalsCopy = new Set(analyzedBundleInfo.externalDependencies.keys());
+	const externals = externalsPreset ? [] : Array.from(externalsCopy);
+	return {
+		logLevel: process.env.MASTRA_BUNDLER_DEBUG === "true" ? "debug" : "silent",
+		treeshake: "smallest",
+		preserveSymlinks: true,
+		external: externals,
+		plugins: [
+			protocolExternalResolver(),
+			subpathExternalsResolver(externals),
+			{
+				name: "alias-optimized-deps",
+				resolveId(id) {
+					if (!analyzedBundleInfo.dependencies.has(id)) return null;
+					const filename = analyzedBundleInfo.dependencies.get(id);
+					const absolutePath = (0, path.join)(workspaceRoot || projectRoot, filename);
+					if (isDev) return {
+						id: process.platform === "win32" ? (0, url.pathToFileURL)(absolutePath).href : absolutePath,
+						external: true
+					};
+					return {
+						id: absolutePath,
+						external: false
+					};
+				}
+			},
+			mastraInternalAliasPlugin(entryFile),
+			tsConfigPaths(),
+			mastraToolsAliasPlugin(),
+			esbuild({
+				platform,
+				define: env
+			}),
+			(0, _optimize_lodash_rollup_plugin.optimizeLodashImports)({ include: "**/*.{js,ts,mjs,cjs}" }),
+			externalsPreset ? null : (0, _rollup_plugin_commonjs.default)({
+				extensions: [".js", ".ts"],
+				transformMixedEsModules: true,
+				esmExternals(id) {
+					return externals.includes(id);
+				}
+			}),
+			enableEsmShim ? esmShim() : void 0,
+			externalsPreset ? nodeModulesExtensionResolver() : nodeResolvePlugin,
+			(0, _rollup_plugin_json.default)(),
+			localStorageDetector(workspaceRoot || projectRoot),
+			removeDeployer(entryFile, { sourcemap }),
+			esbuild({
+				include: entryFile,
+				platform
+			})
+		].filter(Boolean)
+	};
+}
+async function createBundler(inputOptions, outputOptions) {
+	const bundler = await (0, rollup.rollup)(inputOptions);
+	return {
+		write: () => {
+			return bundler.write({
+				...outputOptions,
+				format: "esm",
+				entryFileNames: "[name].mjs",
+				chunkFileNames: "[name].mjs"
+			});
+		},
+		close: () => {
+			return bundler.close();
+		}
+	};
+}
+//#endregion
+Object.defineProperty(exports, "createBundler", {
+	enumerable: true,
+	get: function() {
+		return createBundler;
+	}
+});
+Object.defineProperty(exports, "esbuild", {
+	enumerable: true,
+	get: function() {
+		return esbuild;
+	}
+});
+Object.defineProperty(exports, "esmShim", {
+	enumerable: true,
+	get: function() {
+		return esmShim;
+	}
+});
+Object.defineProperty(exports, "getInputOptions", {
+	enumerable: true,
+	get: function() {
+		return getInputOptions;
+	}
+});
+Object.defineProperty(exports, "getPackageMetadata", {
+	enumerable: true,
+	get: function() {
+		return getPackageMetadata;
+	}
+});
+Object.defineProperty(exports, "getPackageRootPath", {
+	enumerable: true,
+	get: function() {
+		return getPackageRootPath;
+	}
+});
+Object.defineProperty(exports, "mastraInternalAliasPlugin", {
+	enumerable: true,
+	get: function() {
+		return mastraInternalAliasPlugin;
+	}
+});
+Object.defineProperty(exports, "mastraToolsAliasPlugin", {
+	enumerable: true,
+	get: function() {
+		return mastraToolsAliasPlugin;
+	}
+});
+Object.defineProperty(exports, "nodeModulesExtensionResolver", {
+	enumerable: true,
+	get: function() {
+		return nodeModulesExtensionResolver;
+	}
+});
+Object.defineProperty(exports, "protocolExternalResolver", {
+	enumerable: true,
+	get: function() {
+		return protocolExternalResolver;
+	}
+});
+Object.defineProperty(exports, "removeDeployer", {
+	enumerable: true,
+	get: function() {
+		return removeDeployer;
+	}
+});
+Object.defineProperty(exports, "subpathExternalsResolver", {
+	enumerable: true,
+	get: function() {
+		return subpathExternalsResolver;
+	}
+});
+Object.defineProperty(exports, "tsConfigPaths", {
+	enumerable: true,
+	get: function() {
+		return tsConfigPaths;
+	}
+});
+
+//# sourceMappingURL=bundler-BqrDXofn.cjs.map