@mastra/deployer 1.58.0-alpha.12 → 1.58.0-alpha.14

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @mastra/deployer
 
+## 1.58.0-alpha.14
+
+### Patch Changes
+
+- Updated dependencies [[`210cb7a`](https://github.com/mastra-ai/mastra/commit/210cb7a167998c7bbf72cb3b93e6eb0563330239), [`5f798b3`](https://github.com/mastra-ai/mastra/commit/5f798b3362e9bdf4d690f85245606e146eef60b9), [`01a2943`](https://github.com/mastra-ai/mastra/commit/01a2943a7d886edefdff072bfa51f055bab54437), [`01a2943`](https://github.com/mastra-ai/mastra/commit/01a2943a7d886edefdff072bfa51f055bab54437), [`25ca73d`](https://github.com/mastra-ai/mastra/commit/25ca73d25dee7ce9f0ca72939e3a505c4db7257e), [`e1cead1`](https://github.com/mastra-ai/mastra/commit/e1cead17b5f3653cf00d2f90cc19b113119c02ba), [`01a2943`](https://github.com/mastra-ai/mastra/commit/01a2943a7d886edefdff072bfa51f055bab54437)]:
+  - @mastra/core@1.58.0-alpha.14
+  - @mastra/server@1.58.0-alpha.14
+
+## 1.58.0-alpha.13
+
+### Patch Changes
+
+- Updated dependencies [[`9571e3a`](https://github.com/mastra-ai/mastra/commit/9571e3a06ed2c5220196460bf82a2129255c3a8b), [`d6c56f9`](https://github.com/mastra-ai/mastra/commit/d6c56f951db3213330b98b0abafa9778c8770e58), [`9571e3a`](https://github.com/mastra-ai/mastra/commit/9571e3a06ed2c5220196460bf82a2129255c3a8b), [`acc3513`](https://github.com/mastra-ai/mastra/commit/acc3513b19f79bf0a7ec2998694580edca54086c), [`94e7ae9`](https://github.com/mastra-ai/mastra/commit/94e7ae970b37c888cd1244ef013292639a2fe6d1), [`6a667b4`](https://github.com/mastra-ai/mastra/commit/6a667b4b7cd6a93fe41fcdd357b08c5a8c09b9ab), [`2440e09`](https://github.com/mastra-ai/mastra/commit/2440e096ea6c2def1ccc1eb2d0f3f5b88c4af940), [`d6c56f9`](https://github.com/mastra-ai/mastra/commit/d6c56f951db3213330b98b0abafa9778c8770e58), [`a59049b`](https://github.com/mastra-ai/mastra/commit/a59049b1652a13efff66ac826326b5ed9a550342)]:
+  - @mastra/core@1.58.0-alpha.13
+  - @mastra/server@1.58.0-alpha.13
+
 ## 1.58.0-alpha.12
 
 ### Patch Changes

package/dist/build/types.d.ts

@@ -34,12 +34,6 @@ export interface BundlerOptions {
     enableEsmShim: boolean;
     externals: boolean | string[];
     dynamicPackages?: string[];
-    /**
-     * Extra process entries to emit beside the server bundle, as output name ->
-     * absolute source path. Already resolved and validated against the user's
-     * `bundler.entries` config; see `resolveExtraEntries`.
-     */
-    entries?: Record<string, string>;
 }
 /**
  * Version information for an external dependency

package/dist/build/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/build/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC;;OAEG;IACH,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB;;OAEG;IACH,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB;;OAEG;IACH,WAAW,EAAE,OAAO,CAAC;IACrB;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,cAAc;IAC7B,eAAe,EAAE,OAAO,CAAC;IACzB;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,aAAa,EAAE,OAAO,CAAC;IACvB,SAAS,EAAE,OAAO,GAAG,MAAM,EAAE,CAAC;IAC9B,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAClC;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/build/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC;;OAEG;IACH,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB;;OAEG;IACH,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB;;OAEG;IACH,WAAW,EAAE,OAAO,CAAC;IACrB;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,cAAc;IAC7B,eAAe,EAAE,OAAO,CAAC;IACzB;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,aAAa,EAAE,OAAO,CAAC;IACvB,SAAS,EAAE,OAAO,GAAG,MAAM,EAAE,CAAC;IAC9B,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;CAC5B;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB"}

package/dist/bundler/index.cjs

@@ -1,7 +1,509 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_bundler = require("../bundler-DLXwkS7b.cjs");
-exports.Bundler = require_bundler.Bundler;
-exports.IS_DEFAULT = require_bundler.IS_DEFAULT;
-exports.applySourceDependencyRange = require_bundler.applySourceDependencyRange;
-exports.getSourceDependencyConstraints = require_bundler.getSourceDependencyConstraints;
-exports.isRegistryVersionSpec = require_bundler.isRegistryVersionSpec;
+const require_rolldown_runtime = require("../rolldown-runtime-emK7D4bc.cjs");
+const require_analyze = require("../analyze-BIrkd7zx.cjs");
+const require_utils = require("../utils-O98BGdnP.cjs");
+const require_services = require("../services-_ksvysL5.cjs");
+const require_bundler = require("../bundler-DCGtF4jP.cjs");
+const require_bundlerOptions = require("../bundlerOptions-CjjAPZYp.cjs");
+let child_process = require("child_process");
+let fs = require("fs");
+let fs_promises = require("fs/promises");
+let path = require("path");
+let _mastra_core_bundler = require("@mastra/core/bundler");
+let _mastra_core_error = require("@mastra/core/error");
+let _rollup_plugin_virtual = require("@rollup/plugin-virtual");
+_rollup_plugin_virtual = require_rolldown_runtime.__toESM(_rollup_plugin_virtual, 1);
+let empathic_package = require("empathic/package");
+empathic_package = require_rolldown_runtime.__toESM(empathic_package, 1);
+let fs_extra_esm = require("fs-extra/esm");
+fs_extra_esm = require_rolldown_runtime.__toESM(fs_extra_esm, 1);
+let tinyglobby = require("tinyglobby");
+//#region src/bundler/index.ts
+const IS_DEFAULT = Symbol("IS_DEFAULT");
+const NPM_ALIAS_PREFIX = "npm:";
+/** Characters a registry range or dist tag can contain. Protocols need `:`, git shorthand needs `/` or `#`. */
+const REGISTRY_SPEC_PATTERN = /^[A-Za-z0-9.+_^~><=*|!\s-]+$/;
+const PACKAGE_NAME_PATTERN = /^(?:@[A-Za-z0-9._-]+\/)?[A-Za-z0-9._-]+$/;
+const TARBALL_SUFFIX_PATTERN = /\.(?:tgz|tar\.gz|tar)$/i;
+/** npm reads a value starting like this as a path, whatever follows. A bare `~` is a semver range. */
+const FILE_SPEC_PREFIX_PATTERN = /^(?:\.|~[/\\]|[/\\]|[A-Za-z]:[/\\])/;
+/** A range admitting any published version: `*`, `x`, `>=0`, and any union containing one. */
+const UNBOUNDED_RANGE_PATTERN = /(?:^|\|\||\s)\s*(?:[*xX]|>=?\s*0(?:\.0)*(?:\.0)*)\s*(?:$|\|\|)/;
+const toStringRecord = (value) => {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+	return Object.fromEntries(Object.entries(value).filter((entry) => typeof entry[1] === "string"));
+};
+/**
+* True when a specifier is something the isolated install in `.mastra/output` can resolve from the
+* registry: a semver range, a dist tag, a wildcard, or an npm alias whose target is a registry
+* package and range.
+*
+* This is an allowlist rather than a denylist of known protocols, so an unfamiliar protocol is
+* rejected without this code having to know it exists. The output directory is not a workspace, has
+* no catalog definitions and has a different relative-path base, so `catalog:`, `workspace:`,
+* `file:`, `link:` and git specifiers are all either uninstallable there or point somewhere else.
+*/
+const isRegistryVersionSpec = (spec) => {
+	if (FILE_SPEC_PREFIX_PATTERN.test(spec) || TARBALL_SUFFIX_PATTERN.test(spec)) return false;
+	if (spec.startsWith(NPM_ALIAS_PREFIX)) {
+		const alias = spec.slice(4);
+		const rangeSeparator = alias.lastIndexOf("@");
+		const name = rangeSeparator > 0 ? alias.slice(0, rangeSeparator) : alias;
+		const range = rangeSeparator > 0 ? alias.slice(rangeSeparator + 1) : "*";
+		return PACKAGE_NAME_PATTERN.test(name) && isRegistryVersionSpec(range);
+	}
+	return REGISTRY_SPEC_PATTERN.test(spec);
+};
+/**
+* True when a specifier names a version the output install can be held to.
+*
+* A range admitting anything (`*`, `latest`, `>=0`, an alias with no range) is looser than the
+* version already resolved, so writing it would let a later install pull something the bundle was
+* never analyzed against.
+*/
+const isBoundedVersionSpec = (spec) => {
+	const range = spec.startsWith(NPM_ALIAS_PREFIX) ? (() => {
+		const alias = spec.slice(4);
+		const rangeSeparator = alias.lastIndexOf("@");
+		return rangeSeparator > 0 ? alias.slice(rangeSeparator + 1) : "";
+	})() : spec;
+	return /\d/.test(range) && !UNBOUNDED_RANGE_PATTERN.test(range);
+};
+const readManifest = async (manifestPath) => {
+	if (!manifestPath) return;
+	try {
+		const manifest = await (0, fs_extra_esm.readJSON)(manifestPath);
+		return manifest && typeof manifest === "object" ? manifest : void 0;
+	} catch {
+		return;
+	}
+};
+/** Collect the package names a manifest's resolution fields pin, ignoring their values. */
+const collectManifestPinnedNames = (manifest, pinned) => {
+	const pnpmSection = manifest?.pnpm;
+	const records = [
+		manifest?.overrides,
+		manifest?.resolutions,
+		pnpmSection && typeof pnpmSection === "object" ? pnpmSection.overrides : void 0
+	];
+	for (const record of records) if (record && typeof record === "object" && !Array.isArray(record)) for (const key of Object.keys(record)) pinned.add(key);
+};
+/**
+* Collect the names under a top-level `overrides:` block in `pnpm-workspace.yaml`.
+*
+* pnpm moved overrides out of `package.json` into this file, so a workspace on a current pnpm keeps
+* them only here. Reading names off the indented block avoids a YAML dependency, the same tradeoff
+* `copyPnpmWorkspaceSettings` already makes for the top-level keys it copies.
+*/
+const collectPnpmWorkspacePinnedNames = (source, pinned) => {
+	const lines = source.split(/\r?\n/);
+	let insideOverrides = false;
+	for (const line of lines) {
+		if (/^\S/.test(line)) {
+			insideOverrides = /^overrides:\s*$/.test(line);
+			continue;
+		}
+		if (!insideOverrides) continue;
+		const key = /^\s+(?:'([^']+)'|"([^"]+)"|([^'"\s:][^:]*?))\s*:/.exec(line);
+		if (key) pinned.add((key[1] ?? key[2] ?? key[3] ?? "").trim());
+	}
+};
+/**
+* Read the constraints the source app declared.
+*
+* `dependencies` come from the manifest at `projectRoot`, the package the build was invoked for and
+* whose directory receives the output, falling back to the manifest above the entry file. Anchoring
+* on `projectRoot` rather than the entry file keeps the answer deterministic when the entry handed
+* to the bundler is a generated wrapper rather than the app's own source file.
+*
+* Resolution-field names are collected from both that manifest and the workspace root, including the
+* root `pnpm-workspace.yaml`, because a name pinned anywhere means the resolved version may have been
+* chosen deliberately rather than hoisted by accident.
+*/
+const getSourceDependencyConstraints = async ({ projectRoot, mastraEntryFile, workspaceRoot }) => {
+	const manifestPaths = [empathic_package.up({ cwd: projectRoot }), empathic_package.up({ cwd: (0, path.dirname)(mastraEntryFile) })].filter((entry, index, entries) => !!entry && entries.indexOf(entry) === index);
+	if (workspaceRoot) manifestPaths.push((0, path.join)(workspaceRoot, "package.json"));
+	const pinnedByResolutionField = /* @__PURE__ */ new Set();
+	let dependencies;
+	for (const manifestPath of manifestPaths) {
+		const manifest = await readManifest(manifestPath);
+		if (!manifest) continue;
+		dependencies ??= toStringRecord(manifest.dependencies);
+		collectManifestPinnedNames(manifest, pinnedByResolutionField);
+	}
+	if (workspaceRoot) try {
+		collectPnpmWorkspacePinnedNames(await (0, fs_promises.readFile)((0, path.join)(workspaceRoot, "pnpm-workspace.yaml"), "utf-8"), pinnedByResolutionField);
+	} catch {}
+	return {
+		dependencies: dependencies ?? {},
+		pinnedByResolutionField
+	};
+};
+const findDeclaredConstraint = (constraints, dependencyName) => {
+	const names = [dependencyName, require_utils.getPackageName(dependencyName)].filter((name, index, all) => !!name && all.indexOf(name) === index);
+	for (const name of names) if (constraints.pinnedByResolutionField.has(name)) return;
+	for (const name of names) {
+		const declared = (constraints.dependencies[name] ?? "").trim();
+		if (declared && isBoundedVersionSpec(declared) && isRegistryVersionSpec(declared)) return declared;
+	}
+};
+/**
+* Prefer the constraint the app declared over the version resolved from `node_modules`.
+*
+* The resolved version is whatever the install happened to hoist, so an app declaring `zod: ^4.3.6`
+* next to a hoisted `zod@3.25.76` gets the hoisted version written into the output manifest and the
+* isolated install then locks it in.
+*/
+const applySourceDependencyRange = (dependencyName, dependencyInfo, constraints) => {
+	const declared = findDeclaredConstraint(constraints, dependencyName);
+	if (!declared) return dependencyInfo;
+	if (declared.startsWith(NPM_ALIAS_PREFIX)) return {
+		...dependencyInfo,
+		packageSpec: declared
+	};
+	if (dependencyInfo.packageSpec) return dependencyInfo;
+	return {
+		...dependencyInfo,
+		version: declared
+	};
+};
+var Bundler = class extends _mastra_core_bundler.MastraBundler {
+	analyzeOutputDir = ".build";
+	outputDir = "output";
+	platform = "node";
+	constructor(name, component = "BUNDLER") {
+		super({
+			name,
+			component
+		});
+	}
+	async prepare(outputDirectory) {
+		await (0, fs_extra_esm.emptyDir)(outputDirectory);
+		await (0, fs_extra_esm.ensureDir)((0, path.join)(outputDirectory, this.analyzeOutputDir));
+		await (0, fs_extra_esm.ensureDir)((0, path.join)(outputDirectory, this.outputDir));
+	}
+	async writePackageJson(outputDirectory, dependencies, resolutions) {
+		this.logger.debug("Writing project's package.json");
+		await (0, fs_extra_esm.ensureDir)(outputDirectory);
+		const pkgPath = (0, path.join)(outputDirectory, "package.json");
+		const dependenciesMap = /* @__PURE__ */ new Map();
+		for (const [key, value] of dependencies.entries()) {
+			const dependencyValue = typeof value === "string" ? value : value.packageSpec ?? value.version ?? "latest";
+			if (key.startsWith("@")) {
+				const pkgChunks = key.split("/");
+				dependenciesMap.set(`${pkgChunks[0]}/${pkgChunks[1]}`, dependencyValue);
+			} else {
+				const pkgName = key.split("/")[0] || key;
+				dependenciesMap.set(pkgName, dependencyValue);
+			}
+		}
+		await (0, fs_promises.writeFile)(pkgPath, JSON.stringify({
+			name: "server",
+			version: "1.0.0",
+			private: true,
+			type: "module",
+			main: "index.mjs",
+			scripts: { start: "node ./index.mjs" },
+			dependencies: Object.fromEntries(dependenciesMap.entries()),
+			...Object.keys(resolutions ?? {}).length > 0 && { resolutions }
+		}, null, 2));
+	}
+	createBundler(inputOptions, outputOptions) {
+		return require_bundler.createBundler(inputOptions, outputOptions);
+	}
+	async getUserBundlerOptions(mastraEntryFile, outputDirectory) {
+		const defaultBundlerOptions = {
+			externals: [],
+			sourcemap: false,
+			transpilePackages: [],
+			[IS_DEFAULT]: true
+		};
+		try {
+			return await require_bundlerOptions.getBundlerOptions(mastraEntryFile, outputDirectory) ?? defaultBundlerOptions;
+		} catch (error) {
+			this.logger.debug("Failed to get bundler options, sourcemap will be disabled", { error });
+		}
+		return defaultBundlerOptions;
+	}
+	async analyze(entry, mastraFile, outputDirectory) {
+		return await require_analyze.analyzeBundle([].concat(entry), mastraFile, {
+			outputDir: (0, path.join)(outputDirectory, this.analyzeOutputDir),
+			projectRoot: outputDirectory,
+			platform: this.platform
+		}, this.logger);
+	}
+	pnpmNodeLinker;
+	async installDependencies(outputDirectory, rootDir = process.cwd(), pnpmOverrides) {
+		const deps = new require_services.DepsService(rootDir);
+		deps.__setLogger(this.logger);
+		await deps.install({
+			dir: (0, path.join)(outputDirectory, this.outputDir),
+			pnpmOverrides,
+			pnpmNodeLinker: this.pnpmNodeLinker
+		});
+	}
+	/**
+	* Generate a package-lock.json for the output directory so that deploy targets
+	* can use `npm ci` instead of `npm install`, skipping version resolution entirely.
+	* This is a lockfile-only operation — no packages are downloaded.
+	*
+	* Temporarily moves node_modules out of the way because pnpm's symlink-based
+	* layout confuses npm's arborist, then restores it afterwards so that
+	* `mastra start` (or wrangler) can still resolve dependencies at runtime.
+	*/
+	async generateNpmLockfile(outputDir) {
+		const nodeModules = (0, path.join)(outputDir, "node_modules");
+		const nodeModulesTmp = (0, path.join)(outputDir, "node_modules.__tmp");
+		let movedNodeModules = false;
+		try {
+			if (await fs_extra_esm.default.pathExists(nodeModules)) {
+				await fs_extra_esm.default.move(nodeModules, nodeModulesTmp, { overwrite: true });
+				movedNodeModules = true;
+			}
+			(0, child_process.execSync)("npm install --package-lock-only --force", {
+				cwd: outputDir,
+				stdio: "pipe",
+				timeout: 6e4
+			});
+		} catch {
+			this.logger.warn("Failed to generate package-lock.json — deploy will fall back to npm install");
+		} finally {
+			if (movedNodeModules) {
+				await (0, fs_promises.rm)(nodeModules, {
+					recursive: true,
+					force: true
+				});
+				await fs_extra_esm.default.move(nodeModulesTmp, nodeModules, { overwrite: true });
+			}
+		}
+	}
+	async copyPublic(mastraDir, outputDirectory) {
+		const publicDir = (0, path.join)(mastraDir, "public");
+		try {
+			await (0, fs_promises.stat)(publicDir);
+		} catch {
+			return;
+		}
+		await (0, fs_extra_esm.copy)(publicDir, (0, path.join)(outputDirectory, this.outputDir));
+	}
+	async copyDOTNPMRC({ rootDir = process.cwd(), outputDirectory }) {
+		const sourceDotNpmRcPath = (0, path.join)(rootDir, ".npmrc");
+		const targetDotNpmRcPath = (0, path.join)(outputDirectory, this.outputDir, ".npmrc");
+		try {
+			await (0, fs_promises.stat)(sourceDotNpmRcPath);
+			await (0, fs_extra_esm.copy)(sourceDotNpmRcPath, targetDotNpmRcPath);
+		} catch {
+			return;
+		}
+	}
+	/**
+	* Writes the `mastra-project.json` deployment marker for Software Factory
+	* projects after public assets have been copied. Verifies that the Factory
+	* SPA (`factory/index.html`) exists in the output before emitting the marker.
+	*/
+	async writeFactoryMarker(outputDirectory) {
+		const outputDir = (0, path.join)(outputDirectory, this.outputDir);
+		if (!(0, fs.existsSync)((0, path.join)(outputDir, "factory", "index.html"))) throw new _mastra_core_error.MastraError({
+			id: "DEPLOYER_BUNDLER_FACTORY_UI_MISSING",
+			text: "Software Factory project detected but factory/index.html was not found after copying the prebuilt Factory UI.",
+			domain: _mastra_core_error.ErrorDomain.DEPLOYER,
+			category: _mastra_core_error.ErrorCategory.SYSTEM
+		});
+		await (0, fs_promises.writeFile)((0, path.join)(outputDir, "mastra-project.json"), JSON.stringify({
+			schemaVersion: 1,
+			projectType: "factory",
+			assets: { ui: "factory" }
+		}, null, 2));
+		this.logger.info("Wrote mastra-project.json for Software Factory project");
+	}
+	async getBundlerOptions(serverFile, mastraEntryFile, analyzedBundleInfo, toolsPaths, { enableSourcemap, enableMinify, enableEsmShim, externals }) {
+		const { workspaceRoot } = await require_analyze.getWorkspaceInformation({ mastraEntryFile });
+		const closestPkgJson = empathic_package.up({ cwd: (0, path.dirname)(mastraEntryFile) });
+		const projectRoot = closestPkgJson ? (0, path.dirname)(closestPkgJson) : process.cwd();
+		const inputOptions = await require_bundler.getInputOptions(mastraEntryFile, analyzedBundleInfo, this.platform, { "process.env.NODE_ENV": JSON.stringify("production") }, {
+			sourcemap: enableSourcemap,
+			minify: enableMinify,
+			workspaceRoot,
+			projectRoot,
+			enableEsmShim,
+			externalsPreset: externals === true
+		});
+		const isVirtual = serverFile.includes("\n") || !(0, fs.existsSync)(serverFile);
+		const toolsInputOptions = await this.listToolsInputOptions(toolsPaths);
+		if (isVirtual) {
+			inputOptions.input = {
+				index: "#entry",
+				...toolsInputOptions
+			};
+			if (Array.isArray(inputOptions.plugins)) inputOptions.plugins.unshift((0, _rollup_plugin_virtual.default)({ "#entry": serverFile }));
+			else inputOptions.plugins = [(0, _rollup_plugin_virtual.default)({ "#entry": serverFile })];
+		} else inputOptions.input = {
+			index: serverFile,
+			...toolsInputOptions
+		};
+		return inputOptions;
+	}
+	getAllToolPaths(mastraDir, toolsPaths = []) {
+		const normalizedMastraDir = require_utils.slash(mastraDir);
+		const defaultPaths = [path.posix.join(normalizedMastraDir, "tools/**/*.{js,ts}"), ...[`!${path.posix.join(normalizedMastraDir, "tools/**/*.{test,spec}.{js,ts}")}`, `!${path.posix.join(normalizedMastraDir, "tools/**/__tests__/**")}`]];
+		if (toolsPaths.length === 0) return [defaultPaths];
+		return [...toolsPaths, defaultPaths];
+	}
+	async listToolsInputOptions(toolsPaths) {
+		const inputs = {};
+		for (const toolPath of toolsPaths) {
+			const expandedPaths = await (0, tinyglobby.glob)(toolPath, {
+				absolute: true,
+				expandDirectories: false
+			});
+			for (const path$1 of expandedPaths) if (await fs_extra_esm.default.pathExists(path$1)) {
+				const entryFile = new require_services.FileService().getFirstExistingFile([
+					(0, path.join)(path$1, "index.ts"),
+					(0, path.join)(path$1, "index.js"),
+					path$1
+				]);
+				if (!entryFile || (await (0, fs_promises.stat)(entryFile)).isDirectory()) {
+					this.logger.warn("No entry file found, skipping", { path: path$1 });
+					continue;
+				}
+				const uniqueToolID = crypto.randomUUID();
+				const normalizedEntryFile = entryFile.replaceAll("\\", "/");
+				inputs[`tools/${uniqueToolID}`] = normalizedEntryFile;
+			} else this.logger.warn("Tool path does not exist, skipping", { path: path$1 });
+		}
+		return inputs;
+	}
+	async _bundle(serverFile, mastraEntryFile, { projectRoot, outputDirectory, enableEsmShim = true }, toolsPaths = [], bundleLocation = (0, path.join)(outputDirectory, this.outputDir)) {
+		const analyzeDir = (0, path.join)(outputDirectory, this.analyzeOutputDir);
+		const bundlerOptions = await this.getUserBundlerOptions(mastraEntryFile, outputDirectory);
+		const internalBundlerOptions = {
+			enableSourcemap: !!bundlerOptions.sourcemap,
+			enableMinify: !!bundlerOptions.minify,
+			externals: bundlerOptions.externals ?? [],
+			enableEsmShim,
+			dynamicPackages: bundlerOptions.dynamicPackages
+		};
+		let analyzedBundleInfo;
+		try {
+			const resolvedToolsPaths = await this.listToolsInputOptions(toolsPaths);
+			analyzedBundleInfo = await require_analyze.analyzeBundle([serverFile, ...Object.values(resolvedToolsPaths)], mastraEntryFile, {
+				outputDir: analyzeDir,
+				projectRoot,
+				platform: this.platform,
+				bundlerOptions: internalBundlerOptions
+			}, this.logger);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			if (error instanceof _mastra_core_error.MastraError) throw error;
+			throw new _mastra_core_error.MastraError({
+				id: "DEPLOYER_BUNDLER_ANALYZE_FAILED",
+				text: `Failed to analyze Mastra application: ${message}`,
+				domain: _mastra_core_error.ErrorDomain.DEPLOYER,
+				category: _mastra_core_error.ErrorCategory.SYSTEM
+			}, error);
+		}
+		const { workspaceRoot } = await require_analyze.getWorkspaceInformation({
+			dir: projectRoot,
+			mastraEntryFile
+		});
+		const sourceDependencyConstraints = await getSourceDependencyConstraints({
+			projectRoot,
+			mastraEntryFile,
+			workspaceRoot
+		});
+		const dependenciesToInstall = /* @__PURE__ */ new Map();
+		for (const [dep, depInfo] of analyzedBundleInfo.externalDependencies) {
+			if (analyzedBundleInfo.workspaceMap.has(dep) || !require_utils.isBareModuleSpecifier(dep)) continue;
+			dependenciesToInstall.set(dep, applySourceDependencyRange(dep, depInfo, sourceDependencyConstraints));
+		}
+		const initialWorkspaceDependencies = /* @__PURE__ */ new Set();
+		for (const dep of analyzedBundleInfo.dependencies.keys()) {
+			const pkgName = require_utils.getPackageName(dep);
+			if (pkgName && analyzedBundleInfo.workspaceMap.has(pkgName)) initialWorkspaceDependencies.add(pkgName);
+		}
+		const transitiveWorkspaceDependencies = require_analyze.collectTransitiveWorkspaceDependencies({
+			workspaceMap: analyzedBundleInfo.workspaceMap,
+			initialDependencies: initialWorkspaceDependencies,
+			logger: this.logger
+		});
+		for (const [dep, packageSpec] of Object.entries(transitiveWorkspaceDependencies.resolutions)) dependenciesToInstall.set(dep, {
+			version: analyzedBundleInfo.workspaceMap.get(dep)?.version,
+			packageSpec
+		});
+		try {
+			await this.writePackageJson((0, path.join)(outputDirectory, this.outputDir), dependenciesToInstall, transitiveWorkspaceDependencies.resolutions);
+			if (transitiveWorkspaceDependencies.usedWorkspacePackages.size > 0) await require_analyze.packWorkspaceDependencies({
+				workspaceMap: analyzedBundleInfo.workspaceMap,
+				usedWorkspacePackages: transitiveWorkspaceDependencies.usedWorkspacePackages,
+				bundleOutputDir: (0, path.join)(outputDirectory, this.outputDir),
+				logger: this.logger
+			});
+			this.logger.info("Bundling Mastra application");
+			const inputOptions = await this.getBundlerOptions(serverFile, mastraEntryFile, analyzedBundleInfo, toolsPaths, internalBundlerOptions);
+			await (await this.createBundler({
+				...inputOptions,
+				logLevel: inputOptions.logLevel === "silent" ? "warn" : inputOptions.logLevel,
+				onwarn: (warning) => {
+					if (warning.code === "CIRCULAR_DEPENDENCY") {
+						if (warning.ids?.[0]?.includes("node_modules")) return;
+						this.logger.warn("Circular dependency found", { dependency: warning.message.replace("Circular dependency: ", "") });
+					}
+				}
+			}, {
+				dir: bundleLocation,
+				manualChunks: { mastra: ["#mastra"] },
+				sourcemap: internalBundlerOptions.enableSourcemap
+			})).write();
+			const toolImports = [];
+			const toolsExports = [];
+			Array.from(Object.keys(inputOptions.input || {})).filter((key) => key.startsWith("tools/")).forEach((key, index) => {
+				const toolExport = `tool${index}`;
+				toolImports.push(`import * as ${toolExport} from './${key}.mjs';`);
+				toolsExports.push(toolExport);
+			});
+			await (0, fs_promises.writeFile)((0, path.join)(bundleLocation, "tools.mjs"), `${toolImports.join("\n")}
+
+export const tools = [${toolsExports.join(", ")}]`);
+			this.logger.info("Bundling Mastra done");
+			this.logger.info("Copying public files");
+			await this.copyPublic((0, path.dirname)(mastraEntryFile), outputDirectory);
+			this.logger.info("Done copying public files");
+			if (analyzedBundleInfo.projectType === "factory") await this.writeFactoryMarker(outputDirectory);
+			this.logger.info("Copying .npmrc file");
+			await this.copyDOTNPMRC({
+				outputDirectory,
+				rootDir: projectRoot
+			});
+			this.logger.info("Done copying .npmrc file");
+			this.logger.info("Installing dependencies");
+			await this.installDependencies(outputDirectory, projectRoot, transitiveWorkspaceDependencies.resolutions);
+			this.logger.info("Done installing dependencies");
+			if (Object.keys(transitiveWorkspaceDependencies.resolutions).length === 0) {
+				this.logger.info("Generating package-lock.json for deploy");
+				await this.generateNpmLockfile((0, path.join)(outputDirectory, this.outputDir));
+				this.logger.info("Done generating package-lock.json");
+			} else this.logger.warn("Skipping package-lock.json generation because the output contains packed workspace dependencies");
+		} catch (error) {
+			if (error instanceof _mastra_core_error.MastraError && error.id === "DEPLOYER_BUNDLER_FACTORY_UI_MISSING") throw error;
+			throw new _mastra_core_error.MastraError({
+				id: "DEPLOYER_BUNDLER_BUNDLE_STAGE_FAILED",
+				text: `Failed during bundler bundle stage: ${error instanceof Error ? error.message : String(error)}`,
+				domain: _mastra_core_error.ErrorDomain.DEPLOYER,
+				category: _mastra_core_error.ErrorCategory.SYSTEM
+			}, error);
+		}
+	}
+	async lint(_entryFile, _outputDirectory, toolsPaths) {
+		const toolsInputOptions = await this.listToolsInputOptions(toolsPaths);
+		const toolsLength = Object.keys(toolsInputOptions).length;
+		if (toolsLength > 0) this.logger.info("Found tools", { count: toolsLength });
+	}
+};
+//#endregion
+exports.Bundler = Bundler;
+exports.IS_DEFAULT = IS_DEFAULT;
+exports.applySourceDependencyRange = applySourceDependencyRange;
+exports.getSourceDependencyConstraints = getSourceDependencyConstraints;
+exports.isRegistryVersionSpec = isRegistryVersionSpec;
+
+//# sourceMappingURL=index.cjs.map