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

package/dist/bundler-D86rFu2J.js

@@ -0,0 +1,705 @@
+import { a as getPackageName, i as getNodeResolveOptions, l as isDependencyPartOfPackage, p as slash, s as isBareModuleSpecifier, u as isExternalProtocolImport } from "./utils-FVOUvj-I.js";
+import fs, { statSync } from "fs";
+import { readFile } from "fs/promises";
+import path, { dirname, isAbsolute, join, normalize } from "path";
+import { readJSON } from "fs-extra/esm";
+import { transformAsync, types } from "@babel/core";
+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 alias from "@rollup/plugin-alias";
+import nodeResolve from "@rollup/plugin-node-resolve";
+import originalEsbuild from "rollup-plugin-esbuild";
+import originalEsmShim from "@rollup/plugin-esm-shim";
+import { getPackageInfo } from "local-pkg";
+import stripJsonComments from "strip-json-comments";
+import { createHandler } from "typescript-paths";
+//#region src/build/plugins/esbuild.ts
+function esbuild(options = {}) {
+	return originalEsbuild({
+		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 = originalEsmShim();
+	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://") ? fileURLToPath(parentPath) : parentPath;
+	try {
+		if (statSync(fsPath).isFile()) fsPath = dirname(fsPath);
+	} catch {}
+	return 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 getPackageInfo(packageName, options))?.rootPath ?? null;
+	} catch {
+		rootPath = null;
+	}
+	return rootPath;
+}
+async function readPackageMetadata(rootPath, requestedPackageName) {
+	try {
+		const pkgJson = await 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 = 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 readFile(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 = nodeResolve();
+	return {
+		name: "node-modules-extension-resolver",
+		async resolveId(id, importer, options) {
+			if (!importer || !isBareModuleSpecifier(id) || isExternalProtocolImport(id) || 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 = 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 (!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) => types.isObjectProperty(prop) && types.isIdentifier(prop.key) && prop.key.name === "deployer");
+		if (deployerProp) {
+			objectExpr.properties = objectExpr.properties.filter((prop) => prop !== deployerProp);
+			if (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) => types.isVariableDeclarator(path.node))) return;
+			const parentNode = path.parentPath.node;
+			if (!types.isVariableDeclarator(parentNode) || !types.isIdentifier(parentNode.id) || parentNode.id.name !== "mastra") return;
+			if (!state.hasReplaced) {
+				state.hasReplaced = true;
+				const newMastraObj = types.cloneNode(path.node);
+				if (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 (types.isSpreadElement(prop) && types.isIdentifier(prop.argument)) {
+						const spreadBinding = state.file.scope.getBinding(prop.argument.name);
+						if (spreadBinding?.path && types.isVariableDeclarator(spreadBinding.path.node)) {
+							const init = spreadBinding.path.node.init;
+							if (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 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) => 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.readFileSync(tsConfigPath, "utf8");
+		const config = JSON.parse(stripJsonComments(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.existsSync(moduleName)) return moduleName;
+		const parsed = path.parse(moduleName);
+		if (parsed.ext !== ".js") return moduleName;
+		for (const extension of JS_IMPORT_SOURCE_EXTENSIONS) {
+			const candidate = path.join(parsed.dir, `${parsed.name}${extension}`);
+			if (fs.existsSync(candidate)) return candidate;
+		}
+		return moduleName;
+	}
+	function findTsConfigForFile(filePath) {
+		let currentDir = path.dirname(filePath);
+		const root = path.parse(currentDir).root;
+		while (currentDir !== root) {
+			const tsConfigPath = path.join(currentDir, "tsconfig.json");
+			if (fs.existsSync(tsConfigPath)) {
+				if (hasPaths(tsConfigPath)) return tsConfigPath;
+			}
+			const tsConfigBasePath = path.join(currentDir, "tsconfig.base.json");
+			if (fs.existsSync(tsConfigBasePath)) {
+				if (hasPaths(tsConfigBasePath)) return tsConfigBasePath;
+			}
+			currentDir = path.dirname(currentDir);
+		}
+		return null;
+	}
+	function getHandlerForFile(filePath) {
+		if (tsConfigPath && typeof tsConfigPath === "string") {
+			if (!handlerCache.has(tsConfigPath)) handlerCache.set(tsConfigPath, createHandler({
+				log: () => {},
+				tsConfigPath,
+				respectCoreModule,
+				falllback: (moduleName) => fs.existsSync(moduleName)
+			}));
+			return handlerCache.get(tsConfigPath);
+		}
+		const configPath = findTsConfigForFile(filePath);
+		if (!configPath) return null;
+		if (!handlerCache.has(configPath)) handlerCache.set(configPath, createHandler({
+			log: () => {},
+			tsConfigPath: configPath,
+			respectCoreModule,
+			falllback: (moduleName) => fs.existsSync(moduleName)
+		}));
+		return handlerCache.get(configPath);
+	}
+	function resolveAlias(request, importer) {
+		const dynamicHandler = getHandlerForFile(importer);
+		if (!dynamicHandler) return null;
+		return dynamicHandler(request, 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.isAbsolute(importer)) importer = path.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.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 = slash(entryFile);
+	return alias({ entries: [
+		{
+			find: /^\#server$/,
+			replacement: slash(fileURLToPath(import.meta.resolve("@mastra/deployer/server")))
+		},
+		{
+			find: /^\@mastra\/server\/(.*)/,
+			replacement: `@mastra/server/$1`,
+			customResolver: (id) => {
+				if (id.startsWith("@mastra/server")) return { id: fileURLToPath(import.meta.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 = nodeResolve(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 = join(workspaceRoot || projectRoot, filename);
+					if (isDev) return {
+						id: process.platform === "win32" ? pathToFileURL(absolutePath).href : absolutePath,
+						external: true
+					};
+					return {
+						id: absolutePath,
+						external: false
+					};
+				}
+			},
+			mastraInternalAliasPlugin(entryFile),
+			tsConfigPaths(),
+			mastraToolsAliasPlugin(),
+			esbuild({
+				platform,
+				define: env
+			}),
+			optimizeLodashImports({ include: "**/*.{js,ts,mjs,cjs}" }),
+			externalsPreset ? null : commonjs({
+				extensions: [".js", ".ts"],
+				transformMixedEsModules: true,
+				esmExternals(id) {
+					return externals.includes(id);
+				}
+			}),
+			enableEsmShim ? esmShim() : void 0,
+			externalsPreset ? nodeModulesExtensionResolver() : nodeResolvePlugin,
+			json(),
+			localStorageDetector(workspaceRoot || projectRoot),
+			removeDeployer(entryFile, { sourcemap }),
+			esbuild({
+				include: entryFile,
+				platform
+			})
+		].filter(Boolean)
+	};
+}
+async function createBundler(inputOptions, outputOptions) {
+	const bundler = await rollup(inputOptions);
+	return {
+		write: () => {
+			return bundler.write({
+				...outputOptions,
+				format: "esm",
+				entryFileNames: "[name].mjs",
+				chunkFileNames: "[name].mjs"
+			});
+		},
+		close: () => {
+			return bundler.close();
+		}
+	};
+}
+//#endregion
+export { tsConfigPaths as a, protocolExternalResolver as c, getPackageRootPath as d, esmShim as f, mastraToolsAliasPlugin as i, nodeModulesExtensionResolver as l, getInputOptions as n, subpathExternalsResolver as o, esbuild as p, mastraInternalAliasPlugin as r, removeDeployer as s, createBundler as t, getPackageMetadata as u };
+
+//# sourceMappingURL=bundler-D86rFu2J.js.map