@mastra/deployer 0.0.0-error-handler-fix-20251020202607 → 0.0.0-esbuild-bundle-worker-20260807182016

package/dist/build-YV8-9zZy.cjs

@@ -0,0 +1,1158 @@
+const require_rolldown_runtime = require("./rolldown-runtime-emK7D4bc.cjs");
+const require_analyze = require("./analyze-D100622N.cjs");
+const require_utils = require("./utils-O98BGdnP.cjs");
+require("./services-_ksvysL5.cjs");
+const require_bundler = require("./bundler-u9WOUtpl.cjs");
+const require_bundlerOptions = require("./bundlerOptions-CYRir4LE.cjs");
+let fs = require("fs");
+let fs_promises = require("fs/promises");
+let path = require("path");
+let empathic_package = require("empathic/package");
+empathic_package = require_rolldown_runtime.__toESM(empathic_package, 1);
+let tinyglobby = require("tinyglobby");
+let _babel_core = require("@babel/core");
+let rollup = require("rollup");
+let _mastra_core_logger = require("@mastra/core/logger");
+let _mastra_core_agent = require("@mastra/core/agent");
+let gray_matter = require("gray-matter");
+gray_matter = require_rolldown_runtime.__toESM(gray_matter, 1);
+//#region src/build/plugins/workspace-deps-watcher.ts
+const SOURCE_GLOBS = ["**/*.{ts,tsx,js,jsx,mjs,cjs,json}"];
+const SOURCE_IGNORE = ["**/node_modules/**", "**/.cache/**"];
+/**
+* During `mastra dev`, workspace packages are pre-transpiled into
+* `<pkg>/node_modules/.cache/*.mjs` and marked external in the main Rollup
+* watch graph. This plugin:
+* 1. Watches the original workspace package sources so edits trigger rebuilds.
+* 2. Regenerates the optimized `.cache` outputs when those sources change (or
+*    when cache files are missing) before the rebuild finishes — so a later
+*    server restart loads fresh package code.
+*/
+function workspaceDepsWatcher(options) {
+	const { depsToOptimize, optimizedDependencyFiles, workspaceMap, workspaceRoot, outputDir, platform, bundlerOptions } = options;
+	let isFirstBuild = true;
+	const usedPackageRoots = collectUsedPackageRoots(depsToOptimize, workspaceMap);
+	const cachePaths = collectAbsoluteCachePaths(optimizedDependencyFiles, workspaceRoot);
+	return {
+		name: "workspace-deps-watcher",
+		async buildStart() {
+			const sourceFiles = await discoverWorkspaceSourceFiles(usedPackageRoots);
+			for (const file of sourceFiles) this.addWatchFile((0, path.resolve)(file));
+			if (isFirstBuild) {
+				isFirstBuild = false;
+				return;
+			}
+			if (!await isWorkspaceOutputStale(sourceFiles, cachePaths)) return;
+			await require_analyze.bundleExternals(cloneDepsToOptimize(depsToOptimize), outputDir, {
+				bundlerOptions: {
+					...bundlerOptions,
+					externals: bundlerOptions?.externals ?? true,
+					isDev: true
+				},
+				projectRoot: workspaceRoot,
+				workspaceRoot,
+				workspaceMap,
+				platform
+			});
+		}
+	};
+}
+function collectUsedPackageRoots(depsToOptimize, workspaceMap) {
+	const roots = /* @__PURE__ */ new Set();
+	for (const [dep, metadata] of depsToOptimize.entries()) {
+		if (!metadata.isWorkspace) continue;
+		if (metadata.rootPath) {
+			roots.add(require_utils.slash(metadata.rootPath));
+			continue;
+		}
+		const pkgName = require_utils.getPackageName(dep);
+		const location = pkgName ? workspaceMap.get(pkgName)?.location : void 0;
+		if (location) roots.add(require_utils.slash(location));
+	}
+	return Array.from(roots);
+}
+function collectAbsoluteCachePaths(optimizedDependencyFiles, workspaceRoot) {
+	return Array.from(optimizedDependencyFiles.values()).map((relativePath) => (0, path.resolve)(workspaceRoot, relativePath));
+}
+async function discoverWorkspaceSourceFiles(packageRoots) {
+	if (packageRoots.length === 0) return [];
+	return (await Promise.all(packageRoots.map((root) => (0, tinyglobby.glob)(SOURCE_GLOBS, {
+		cwd: root,
+		absolute: true,
+		ignore: SOURCE_IGNORE,
+		onlyFiles: true
+	})))).flat();
+}
+async function isCacheMissing(cachePaths) {
+	for (const cachePath of cachePaths) if (!(0, fs.existsSync)(cachePath)) return true;
+	return false;
+}
+async function isWorkspaceOutputStale(sourceFiles, cachePaths) {
+	if (await isCacheMissing(cachePaths)) return true;
+	let cacheBaselineMs = 0;
+	for (const cachePath of cachePaths) try {
+		const { mtimeMs } = await (0, fs_promises.stat)(cachePath);
+		cacheBaselineMs = Math.max(cacheBaselineMs, mtimeMs);
+	} catch {
+		return true;
+	}
+	for (const file of sourceFiles) try {
+		const { mtimeMs } = await (0, fs_promises.stat)(file);
+		if (mtimeMs > cacheBaselineMs) return true;
+	} catch {
+		return true;
+	}
+	return false;
+}
+function cloneDepsToOptimize(deps) {
+	const copy = /* @__PURE__ */ new Map();
+	for (const [dep, metadata] of deps.entries()) copy.set(dep, {
+		...metadata,
+		exports: [...metadata.exports]
+	});
+	return copy;
+}
+//#endregion
+//#region src/build/watcher.ts
+async function getInputOptions(entryFile, platform, env, { sourcemap = false, bundlerOptions = {
+	enableSourcemap: false,
+	enableEsmShim: true,
+	externals: true
+}, analysisEntries = [entryFile] } = {}) {
+	const closestPkgJson = empathic_package.up({ cwd: (0, path.dirname)(entryFile) });
+	const projectRoot = closestPkgJson ? (0, path.dirname)(require_utils.slash(closestPkgJson)) : require_utils.slash(process.cwd());
+	const { workspaceMap, workspaceRoot } = await require_analyze.getWorkspaceInformation({ mastraEntryFile: entryFile });
+	const outputDir = path.posix.join(process.cwd(), ".mastra", ".build");
+	const analyzeEntryResult = await require_analyze.analyzeBundle(analysisEntries, entryFile, {
+		outputDir,
+		projectRoot: workspaceRoot || process.cwd(),
+		platform,
+		isDev: true,
+		bundlerOptions
+	}, _mastra_core_logger.noopLogger);
+	const deps = /* @__PURE__ */ new Map();
+	for (const [dep, metadata] of analyzeEntryResult.dependencies.entries()) {
+		const pkgName = require_utils.getPackageName(dep);
+		if (pkgName && workspaceMap.has(pkgName)) deps.set(dep, metadata);
+	}
+	const inputOptions = await require_bundler.getInputOptions(entryFile, {
+		dependencies: deps,
+		externalDependencies: /* @__PURE__ */ new Map(),
+		workspaceMap
+	}, platform, env, {
+		sourcemap,
+		isDev: true,
+		workspaceRoot,
+		projectRoot,
+		externalsPreset: bundlerOptions?.externals === true
+	});
+	if (Array.isArray(inputOptions.plugins)) {
+		const plugins = [];
+		inputOptions.plugins.forEach((plugin) => {
+			if (plugin?.name === "node-resolve") return;
+			if (plugin?.name === "tsconfig-paths") {
+				plugins.push(require_bundler.tsConfigPaths({ localResolve: true }));
+				return;
+			}
+			plugins.push(plugin);
+		});
+		inputOptions.plugins = plugins;
+		inputOptions.plugins.push(require_analyze.aliasHono());
+		inputOptions.plugins.push(require_bundler.nodeModulesExtensionResolver());
+		const depsToOptimize = analyzeEntryResult.depsToOptimize;
+		const resolvedWorkspaceRoot = analyzeEntryResult.workspaceRoot || workspaceRoot;
+		if (depsToOptimize?.size && resolvedWorkspaceRoot) inputOptions.plugins.push(workspaceDepsWatcher({
+			depsToOptimize,
+			optimizedDependencyFiles: deps,
+			workspaceMap,
+			workspaceRoot: resolvedWorkspaceRoot,
+			outputDir: analyzeEntryResult.outputDir || outputDir,
+			platform,
+			bundlerOptions
+		}));
+	}
+	return inputOptions;
+}
+async function createWatcher(inputOptions, outputOptions) {
+	return await (0, rollup.watch)({
+		...inputOptions,
+		output: {
+			...outputOptions,
+			format: "esm",
+			entryFileNames: "[name].mjs",
+			chunkFileNames: "[name].mjs"
+		}
+	});
+}
+//#endregion
+//#region src/build/analyzeEntryProjectType.ts
+/**
+* Lightweight entry analysis that returns the detected project type by running
+* only the Babel check-config-export plugin on the Mastra entry file. This is
+* intentionally cheaper than `analyzeBundle` and is used by the CLI before
+* `prepare()` clears `.mastra` to decide whether Factory-specific assets
+* should be copied.
+*
+* Returns `'factory'` when the entry imports `MastraFactory` and
+* constructs it, or `undefined` for ordinary Mastra projects.
+*/
+async function analyzeEntryProjectType(mastraEntry) {
+	const code = await (0, fs_promises.readFile)(mastraEntry, "utf-8");
+	const result = { hasValidConfig: false };
+	await (0, _babel_core.transformAsync)(code, {
+		filename: mastraEntry,
+		presets: [{}.resolve("@babel/preset-typescript")],
+		plugins: [() => require_analyze.checkConfigExport(result)]
+	});
+	return result.projectType;
+}
+//#endregion
+//#region src/build/serverOptions.ts
+async function getServerOptions(entryFile, outputDir, logger) {
+	const result = await require_bundlerOptions.extractMastraOption("server", entryFile, outputDir, logger);
+	if (!result) return null;
+	return result.getConfig();
+}
+//#endregion
+//#region src/build/fs-routing/discover.ts
+/**
+* Frontmatter keys a markdown schedule may set, in the order they are copied
+* onto the definition. Anything outside this list fails the build rather than
+* being silently dropped — a schedule that quietly ignores half its config is
+* worse than one that refuses to build.
+*
+* The `satisfies` binds this list to core's definition type, so renaming or
+* removing a field there breaks the build here instead of silently rejecting
+* frontmatter that used to be valid. (`prompt` is excluded because the document
+* body supplies it, `handler` because markdown can't carry a function.)
+*/
+const MARKDOWN_SCHEDULE_KEYS = [
+	"cron",
+	"timezone",
+	"name",
+	"threadId",
+	"resourceId",
+	"signalType",
+	"tagName",
+	"attributes",
+	"providerOptions",
+	"ifActive",
+	"ifIdle",
+	"status",
+	"metadata"
+];
+const CONFIG_BASENAMES = ["config.ts", "config.js"];
+const WORKSPACE_BASENAMES = ["workspace.ts", "workspace.js"];
+const MEMORY_BASENAMES = ["memory.ts", "memory.js"];
+const INSTRUCTIONS_BASENAME = "instructions.md";
+const INSTRUCTIONS_MODULE_BASENAMES = ["instructions.ts", "instructions.js"];
+const TOOL_EXTENSIONS = [".ts", ".js"];
+const SCHEDULE_MODULE_EXTENSIONS = [".ts", ".js"];
+const SKILL_MODULE_EXTENSIONS = [".ts", ".js"];
+const SKILL_MD_BASENAME = "SKILL.md";
+/**
+* Presence check that does NOT follow symlinks. Returns `false` for symlinks
+* (and broken links) so a symlinked `config.ts`/`instructions.md`/
+* `instructions.ts`/`workspace.ts`/`memory.ts` is never inlined or imported
+* into the generated bundle.
+*/
+async function exists(path$1) {
+	try {
+		return !(await (0, fs_promises.lstat)(path$1)).isSymbolicLink();
+	} catch {
+		return false;
+	}
+}
+/**
+* Returns the slash-normalized path when `path` is a real directory (not a
+* symlink). Symlinked directories are rejected to prevent the build from
+* following links out of the project tree during discovery.
+*/
+async function realDirectory(path$2) {
+	try {
+		const info = await (0, fs_promises.lstat)(path$2);
+		if (info.isDirectory() && !info.isSymbolicLink()) return require_utils.slash(path$2);
+	} catch {}
+}
+async function directoryExists(path$3) {
+	return realDirectory(path$3);
+}
+async function firstExisting(dir, basenames) {
+	for (const basename of basenames) {
+		const candidate = (0, path.join)(dir, basename);
+		if (await exists(candidate)) return require_utils.slash(candidate);
+	}
+}
+function isTestFile(basename) {
+	return /\.(test|spec)\.(ts|js)$/.test(basename);
+}
+function toolKey(basename) {
+	return basename.replace(/\.(ts|js)$/, "");
+}
+/**
+* Discover default-exporting `.ts`/`.js` modules directly under `dir`, returning
+* `{ key, path }` entries in stable (sorted) order. Test files, symlinks, and
+* subdirectories are skipped: a symlinked module could point anywhere on the
+* build machine and be embedded into generated import code. Shared by the
+* `tools/` and `scorers/` scanners.
+*/
+async function discoverModuleDir(dir) {
+	if (!await exists(dir)) return [];
+	let entries;
+	try {
+		entries = await (0, fs_promises.readdir)(dir);
+	} catch {
+		return [];
+	}
+	const modules = [];
+	for (const basename of entries.sort()) {
+		if (isTestFile(basename)) continue;
+		if (!TOOL_EXTENSIONS.some((ext) => basename.endsWith(ext))) continue;
+		const path$4 = (0, path.join)(dir, basename);
+		const stats = await (0, fs_promises.lstat)(path$4);
+		if (stats.isSymbolicLink() || stats.isDirectory()) continue;
+		modules.push({
+			key: toolKey(basename),
+			path: require_utils.slash(path$4)
+		});
+	}
+	return modules;
+}
+async function discoverTools(toolsDir) {
+	return discoverModuleDir(toolsDir);
+}
+async function discoverProcessors(processorsDir) {
+	const result = {
+		input: [],
+		output: []
+	};
+	for (const type of ["input", "output"]) {
+		const typeDir = (0, path.join)(processorsDir, type);
+		if (!await exists(typeDir)) continue;
+		let entries;
+		try {
+			entries = await (0, fs_promises.readdir)(typeDir);
+		} catch {
+			continue;
+		}
+		for (const basename of entries.sort()) {
+			if (isTestFile(basename)) continue;
+			if (!TOOL_EXTENSIONS.some((ext) => basename.endsWith(ext))) continue;
+			const path$5 = (0, path.join)(typeDir, basename);
+			const stats = await (0, fs_promises.lstat)(path$5);
+			if (stats.isSymbolicLink() || stats.isDirectory()) continue;
+			result[type].push({
+				key: toolKey(basename),
+				path: require_utils.slash(path$5)
+			});
+		}
+	}
+	return result;
+}
+async function readReferences(referencesDir) {
+	if (!await exists(referencesDir)) return {};
+	const references = {};
+	let entries;
+	try {
+		entries = await (0, fs_promises.readdir)(referencesDir);
+	} catch {
+		return {};
+	}
+	for (const basename of entries.sort()) {
+		const path$6 = (0, path.join)(referencesDir, basename);
+		const stats = await (0, fs_promises.lstat)(path$6);
+		if (stats.isSymbolicLink() || stats.isDirectory()) continue;
+		references[basename] = await (0, fs_promises.readFile)(path$6, "utf-8");
+	}
+	return references;
+}
+async function parsePackagedSkill(skillMdPath, fallbackName, references = {}) {
+	const parsed = (0, gray_matter.default)(await (0, fs_promises.readFile)(skillMdPath, "utf-8"));
+	const frontmatter = parsed.data;
+	const name = frontmatter.name ?? fallbackName;
+	const description = frontmatter.description;
+	if (!description) throw new Error(`Skill "${name}" in ${skillMdPath} is missing a required "description". Add a YAML frontmatter block with a "description:" field. See https://agentskills.io/specification for the SKILL.md format.`);
+	return {
+		kind: "packaged",
+		name,
+		description,
+		instructions: parsed.content.trim(),
+		references
+	};
+}
+function skillModuleName(basename) {
+	return basename.replace(/\.(ts|js)$/, "");
+}
+async function discoverSkills(skillsDir) {
+	if (!await exists(skillsDir)) return [];
+	let entries;
+	try {
+		entries = await (0, fs_promises.readdir)(skillsDir);
+	} catch {
+		return [];
+	}
+	const skills = [];
+	for (const basename of entries.sort()) {
+		if (isTestFile(basename)) continue;
+		const path$7 = (0, path.join)(skillsDir, basename);
+		const stats = await (0, fs_promises.lstat)(path$7);
+		if (stats.isSymbolicLink()) continue;
+		if (stats.isDirectory()) {
+			const skillMd = (0, path.join)(path$7, SKILL_MD_BASENAME);
+			if (await exists(skillMd)) {
+				const references = await readReferences((0, path.join)(path$7, "references"));
+				skills.push(await parsePackagedSkill(skillMd, skillModuleName(basename), references));
+			}
+			continue;
+		}
+		if (SKILL_MODULE_EXTENSIONS.some((ext) => basename.endsWith(ext))) {
+			skills.push({
+				kind: "module",
+				path: require_utils.slash(path$7)
+			});
+			continue;
+		}
+		if (basename.endsWith(".md")) {
+			const skill = await parsePackagedSkill(path$7, basename.replace(/\.md$/, ""));
+			skills.push(skill);
+		}
+	}
+	return skills;
+}
+/**
+* Parse a markdown schedule: YAML frontmatter for the cron (and other JSON-safe
+* options), document body for the prompt.
+*
+* Throws a build error naming the file when `cron` is missing or the body is
+* empty — a schedule that can't fire is never what the author meant.
+*/
+async function parseMarkdownSchedule(path$8, key) {
+	const raw = await (0, fs_promises.readFile)(path$8, "utf-8");
+	let parsed;
+	try {
+		parsed = (0, gray_matter.default)(raw);
+	} catch (error) {
+		const detail = error instanceof Error ? error.message.split("\n")[0] : String(error);
+		throw new Error(`Schedule "${key}" in ${path$8} has invalid YAML frontmatter: ${detail}. Cron expressions must be quoted (cron: "*/5 * * * *"), because a leading "*" is a YAML alias.`);
+	}
+	const frontmatter = parsed.data ?? {};
+	const prompt = parsed.content.trim();
+	const unknown = Object.keys(frontmatter).filter((field) => !MARKDOWN_SCHEDULE_KEYS.includes(field));
+	if (unknown.length > 0) {
+		const hint = unknown.includes("prompt") ? ` The document body is used as the prompt, so "prompt" cannot be set in frontmatter.` : ` Supported fields: ${MARKDOWN_SCHEDULE_KEYS.join(", ")}. Handler mode requires a .ts or .js schedule.`;
+		throw new Error(`Schedule "${key}" in ${path$8} has unknown frontmatter field(s): ${unknown.join(", ")}.${hint}`);
+	}
+	if (!frontmatter.cron || typeof frontmatter.cron !== "string") throw new Error(`Schedule "${key}" in ${path$8} is missing a required "cron". Add a YAML frontmatter block with a "cron:" field (e.g. cron: "0 9 * * *").`);
+	if (!prompt) throw new Error(`Schedule "${key}" in ${path$8} has an empty body. The document body is used as the prompt, so it cannot be blank.`);
+	const definition = {
+		cron: frontmatter.cron,
+		prompt
+	};
+	for (const field of MARKDOWN_SCHEDULE_KEYS) {
+		if (field === "cron") continue;
+		if (frontmatter[field] !== void 0) definition[field] = frontmatter[field];
+	}
+	return definition;
+}
+/**
+* Discover schedules under `agents/<name>/schedules/`, recursing into
+* subdirectories so a schedule's identity is its path relative to `schedules/`
+* with the extension stripped (`billing/sweep.ts` → `billing/sweep`).
+*
+* Test files and symlinks (files and directories alike) are skipped for the
+* same reason as the other scanners: a symlink could point anywhere on the
+* build machine and be embedded into generated import code.
+*/
+async function discoverSchedules(schedulesDir, prefix = "") {
+	if (!await exists(schedulesDir)) return [];
+	let entries;
+	try {
+		entries = await (0, fs_promises.readdir)(schedulesDir);
+	} catch {
+		return [];
+	}
+	const schedules = [];
+	for (const basename of entries.sort()) {
+		const path$9 = (0, path.join)(schedulesDir, basename);
+		let stats;
+		try {
+			stats = await (0, fs_promises.lstat)(path$9);
+		} catch {
+			continue;
+		}
+		if (stats.isSymbolicLink()) continue;
+		if (stats.isDirectory()) {
+			schedules.push(...await discoverSchedules(path$9, `${prefix}${basename}/`));
+			continue;
+		}
+		if (isTestFile(basename)) continue;
+		if (SCHEDULE_MODULE_EXTENSIONS.some((ext) => basename.endsWith(ext))) {
+			schedules.push({
+				kind: "module",
+				key: `${prefix}${basename.replace(/\.(ts|js)$/, "")}`,
+				path: require_utils.slash(path$9)
+			});
+			continue;
+		}
+		if (basename.endsWith(".md")) {
+			const key = `${prefix}${basename.replace(/\.md$/, "")}`;
+			schedules.push({
+				kind: "markdown",
+				key,
+				path: require_utils.slash(path$9),
+				definition: await parseMarkdownSchedule(path$9, key)
+			});
+		}
+	}
+	return schedules.sort((left, right) => left.key < right.key ? -1 : left.key > right.key ? 1 : 0);
+}
+/**
+* Discover a single agent directory: its `config`/`instructions`/`workspace`
+* files plus `tools/`, `skills/`, and declared `subagents/`. Returns
+* `undefined` when `dir` is not an agent directory (no `config.(ts|js)`, no
+* `instructions.md`, and no `instructions.(ts|js)`).
+*
+* `depth` is the subagent nesting level (`0` for top-level agents). Discovery
+* recurses into `subagents/` until `MAX_FS_SUBAGENT_DEPTH`; deeper directories
+* are ignored with a warning.
+*/
+async function discoverAgentDir(dir, name, depth, onWarn) {
+	const configPath = await firstExisting(dir, CONFIG_BASENAMES);
+	const instructionsPath = await exists((0, path.join)(dir, INSTRUCTIONS_BASENAME)) ? require_utils.slash((0, path.join)(dir, INSTRUCTIONS_BASENAME)) : void 0;
+	const instructionsModulePath = await firstExisting(dir, INSTRUCTIONS_MODULE_BASENAMES);
+	if (!configPath && !instructionsPath && !instructionsModulePath) return;
+	const workspacePath = await firstExisting(dir, WORKSPACE_BASENAMES);
+	const memoryPath = await firstExisting(dir, MEMORY_BASENAMES);
+	const workspaceSeedDir = await directoryExists((0, path.join)(dir, "workspace"));
+	const tools = await discoverTools((0, path.join)(dir, "tools"));
+	const processors = await discoverProcessors((0, path.join)(dir, "processors"));
+	const scorers = await discoverModuleDir((0, path.join)(dir, "scorers"));
+	const skills = await discoverSkills((0, path.join)(dir, "skills"));
+	const schedules = await discoverSchedules((0, path.join)(dir, "schedules"));
+	const subagents = await discoverSubagents(dir, depth, onWarn);
+	return {
+		name,
+		dir: require_utils.slash(dir),
+		configPath,
+		instructionsPath,
+		instructionsModulePath,
+		workspacePath,
+		memoryPath,
+		workspaceSeedDir,
+		tools,
+		inputProcessors: processors.input,
+		outputProcessors: processors.output,
+		scorers,
+		skills,
+		schedules,
+		subagents
+	};
+}
+/**
+* Discover declared subagents under `<dir>/subagents/*`. `parentDepth` is the
+* parent agent's nesting level (`0` for top-level agents). Discovery recurses
+* until `MAX_FS_SUBAGENT_DEPTH` levels of subagents; a `subagents/` directory
+* that would exceed the cap is skipped with a warning.
+*/
+async function discoverSubagents(parentDir, parentDepth, onWarn) {
+	const subagentsDir = (0, path.join)(parentDir, "subagents");
+	if (!await exists(subagentsDir)) return [];
+	if (parentDepth >= _mastra_core_agent.MAX_FS_SUBAGENT_DEPTH) {
+		onWarn?.(`Ignoring subagents in "${require_utils.slash(subagentsDir)}": subagents may only nest ${_mastra_core_agent.MAX_FS_SUBAGENT_DEPTH} levels below a top-level agent.`);
+		return [];
+	}
+	let entries;
+	try {
+		entries = await (0, fs_promises.readdir)(subagentsDir);
+	} catch {
+		return [];
+	}
+	const subagents = [];
+	for (const name of entries.sort()) {
+		const dir = (0, path.join)(subagentsDir, name);
+		if (!await realDirectory(dir)) continue;
+		const child = await discoverAgentDir(dir, name, parentDepth + 1, onWarn);
+		if (child) subagents.push(child);
+	}
+	return subagents;
+}
+/**
+* Scan `<mastraDir>/agents/*` for file-system routed agents. A directory is
+* treated as an agent only when it contains a `config.(ts|js)`, an
+* `instructions.md`, or an `instructions.(ts|js)`; other directories are
+* ignored. Each agent may declare `subagents/` up to `MAX_FS_SUBAGENT_DEPTH`
+* levels deep. Returns descriptors with absolute, slash-normalized paths ready
+* for codegen. Performs no module evaluation — only filesystem inspection.
+*/
+async function discoverFsAgents(mastraDir, onWarn) {
+	const agentsDir = (0, path.join)(mastraDir, "agents");
+	if (!await exists(agentsDir)) return [];
+	let entries;
+	try {
+		entries = await (0, fs_promises.readdir)(agentsDir);
+	} catch {
+		return [];
+	}
+	const discovered = [];
+	for (const name of entries.sort()) {
+		const dir = (0, path.join)(agentsDir, name);
+		if (!await realDirectory(dir)) continue;
+		const agent = await discoverAgentDir(dir, name, 0, onWarn);
+		if (agent) discovered.push(agent);
+	}
+	return discovered;
+}
+/**
+* Scan `<mastraDir>/workflows/` for file-system routed workflow modules. Only
+* files whose source contains an `export default` are treated as fs-routed
+* workflows — this convention distinguishes them from workflow files that are
+* manually imported and registered programmatically. Returns descriptors with
+* absolute, slash-normalized paths ready for codegen. Performs no module
+* evaluation — only filesystem and source-text inspection.
+*/
+async function discoverFsWorkflows(mastraDir) {
+	const workflowsDir = (0, path.join)(mastraDir, "workflows");
+	if (!await exists(workflowsDir)) return [];
+	let entries;
+	try {
+		entries = await (0, fs_promises.readdir)(workflowsDir);
+	} catch {
+		return [];
+	}
+	const discovered = [];
+	for (const basename of entries.sort()) {
+		if (isTestFile(basename)) continue;
+		if (!TOOL_EXTENSIONS.some((ext) => basename.endsWith(ext))) continue;
+		const path$10 = (0, path.join)(workflowsDir, basename);
+		const stats = await (0, fs_promises.lstat)(path$10);
+		if (stats.isSymbolicLink() || stats.isDirectory()) continue;
+		const source = await (0, fs_promises.readFile)(path$10, "utf-8");
+		if (!/\bexport\s+default\b/.test(source)) continue;
+		discovered.push({
+			key: toolKey(basename),
+			path: require_utils.slash(path$10)
+		});
+	}
+	return discovered;
+}
+const SINGLETON_EXTENSIONS = [
+	".ts",
+	".js",
+	".mts",
+	".mjs"
+];
+/** Safe singleton identifier: no path separators, `..`, or other traversal. */
+const SINGLETON_NAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
+/**
+* Check for a singleton config file (e.g. `storage.ts`, `storage.js`) directly
+* under `<mastraDir>`. Returns the first matching file path or `undefined`.
+* Symlinks are rejected for security.
+*
+* Convention: only files with `export default` are fs-routed singletons. Files
+* using named exports are assumed to be manually imported into the user's
+* `index.ts`, so they are ignored to remain backward-compatible with existing
+* project structures.
+*
+* `name` must be a bare identifier — path separators and traversal sequences are
+* rejected so the lookup can never escape `<mastraDir>`.
+*/
+async function discoverFsSingleton(mastraDir, name) {
+	if (!SINGLETON_NAME_PATTERN.test(name)) throw new Error(`Invalid fs-singleton name ${JSON.stringify(name)}: expected a bare identifier.`);
+	for (const ext of SINGLETON_EXTENSIONS) {
+		const candidate = (0, path.join)(mastraDir, `${name}${ext}`);
+		try {
+			const stats = await (0, fs_promises.lstat)(candidate);
+			if (!stats.isFile() || stats.isSymbolicLink()) continue;
+			const source = await (0, fs_promises.readFile)(candidate, "utf-8");
+			if (!/\bexport\s+default\b/.test(source)) continue;
+			return { path: require_utils.slash(candidate) };
+		} catch {}
+	}
+}
+//#endregion
+//#region src/build/fs-routing/codegen.ts
+function sanitizeIdentifier(name, prefix, index) {
+	return `${prefix}_${index}_${name.replace(/[^a-zA-Z0-9_$]/g, "_")}`;
+}
+/**
+* Emit the imports for a single discovered agent into `lines` and return the
+* source of its `assembleAgentFromFsEntry` entry object (the `{ name, config,
+* ... }` argument). `idPath` is a dot-free, unique path index (e.g. `0` for the
+* first top-level agent, `0_1` for its second subagent) used to keep generated
+* identifiers unique across the parent/child tree. `workspaceName` is the
+* slash-joined workspace key (`<parent>/<child>` for subagents) so seed files
+* don't collide. Discovered subagents are emitted recursively as a nested
+* `subagents: [...]` field (discovery already enforces the depth cap).
+*/
+async function emitAgentEntry(agent, idPath, workspaceName, lines) {
+	const configIdent = sanitizeIdentifier(agent.name, "config", idPath);
+	const toolIdents = [];
+	if (agent.configPath) lines.push(`import ${configIdent} from ${JSON.stringify(agent.configPath)};`);
+	let workspaceIdent;
+	if (agent.workspacePath) {
+		workspaceIdent = sanitizeIdentifier(`${agent.name}_workspace`, "workspace", idPath);
+		lines.push(`import ${workspaceIdent} from ${JSON.stringify(agent.workspacePath)};`);
+	}
+	let memoryIdent;
+	if (agent.memoryPath) {
+		memoryIdent = sanitizeIdentifier(`${agent.name}_memory`, "memory", idPath);
+		lines.push(`import ${memoryIdent} from ${JSON.stringify(agent.memoryPath)};`);
+	}
+	let instructionsIdent;
+	if (agent.instructionsModulePath) {
+		instructionsIdent = sanitizeIdentifier(`${agent.name}_instructions`, "instructions", idPath);
+		lines.push(`import ${instructionsIdent} from ${JSON.stringify(agent.instructionsModulePath)};`);
+	}
+	for (let t = 0; t < agent.tools.length; t++) {
+		const tool = agent.tools[t];
+		const ident = sanitizeIdentifier(`${agent.name}_${tool.key}`, "tool", `${idPath}_${t}`);
+		lines.push(`import ${ident} from ${JSON.stringify(tool.path)};`);
+		toolIdents.push({
+			key: tool.key,
+			ident
+		});
+	}
+	const inputProcessorIdents = [];
+	for (let p = 0; p < agent.inputProcessors.length; p++) {
+		const proc = agent.inputProcessors[p];
+		const ident = sanitizeIdentifier(`${agent.name}_inputProc_${proc.key}`, "proc", `${idPath}_ip${p}`);
+		lines.push(`import ${ident} from ${JSON.stringify(proc.path)};`);
+		inputProcessorIdents.push(ident);
+	}
+	const outputProcessorIdents = [];
+	for (let p = 0; p < agent.outputProcessors.length; p++) {
+		const proc = agent.outputProcessors[p];
+		const ident = sanitizeIdentifier(`${agent.name}_outputProc_${proc.key}`, "proc", `${idPath}_op${p}`);
+		lines.push(`import ${ident} from ${JSON.stringify(proc.path)};`);
+		outputProcessorIdents.push(ident);
+	}
+	const scorerIdents = [];
+	for (let s = 0; s < agent.scorers.length; s++) {
+		const scorer = agent.scorers[s];
+		const ident = sanitizeIdentifier(`${agent.name}_scorer_${scorer.key}`, "scorer", `${idPath}_${s}`);
+		lines.push(`import ${ident} from ${JSON.stringify(scorer.path)};`);
+		scorerIdents.push({
+			key: scorer.key,
+			ident
+		});
+	}
+	const skillExprs = [];
+	const agentSkills = agent.skills ?? [];
+	for (let s = 0; s < agentSkills.length; s++) {
+		const skill = agentSkills[s];
+		if (skill.kind === "module") {
+			const ident = sanitizeIdentifier(`${agent.name}_skill`, "skill", `${idPath}_${s}`);
+			lines.push(`import ${ident} from ${JSON.stringify(skill.path)};`);
+			skillExprs.push(ident);
+		} else {
+			const referenceFields = Object.entries(skill.references).map(([key, value]) => `${JSON.stringify(key)}: ${JSON.stringify(value)}`);
+			const skillFields = [
+				`name: ${JSON.stringify(skill.name)}`,
+				`description: ${JSON.stringify(skill.description)}`,
+				`instructions: ${JSON.stringify(skill.instructions)}`
+			];
+			if (referenceFields.length > 0) skillFields.push(`references: { ${referenceFields.join(", ")} }`);
+			skillExprs.push(`__createSkill({ ${skillFields.join(", ")} })`);
+		}
+	}
+	const scheduleExprs = [];
+	const agentSchedules = agent.schedules ?? [];
+	for (let s = 0; s < agentSchedules.length; s++) {
+		const schedule = agentSchedules[s];
+		const keyField = `key: ${JSON.stringify(schedule.key)}`;
+		if (schedule.kind === "module") {
+			const ident = sanitizeIdentifier(`${agent.name}_schedule`, "schedule", `${idPath}_${s}`);
+			lines.push(`import ${ident} from ${JSON.stringify(schedule.path)};`);
+			scheduleExprs.push(`{ ${keyField}, schedule: ${ident} }`);
+		} else scheduleExprs.push(`{ ${keyField}, schedule: ${JSON.stringify(schedule.definition)} }`);
+	}
+	let instructionsMd;
+	if (agent.instructionsPath) instructionsMd = await (0, fs_promises.readFile)(agent.instructionsPath, "utf-8");
+	const subagentExprs = [];
+	for (let c = 0; c < agent.subagents.length; c++) {
+		const child = agent.subagents[c];
+		const childExpr = await emitAgentEntry(child, `${idPath}_${c}`, `${workspaceName}/${child.name}`, lines);
+		subagentExprs.push(childExpr);
+	}
+	const entryFields = [`name: ${JSON.stringify(agent.name)}`];
+	if (agent.configPath) entryFields.push(`config: ${configIdent}`);
+	if (instructionsIdent) entryFields.push(`instructions: ${instructionsIdent}`);
+	if (instructionsMd !== void 0) entryFields.push(`instructionsMd: ${JSON.stringify(instructionsMd)}`);
+	if (toolIdents.length > 0) {
+		const toolEntries = toolIdents.map(({ key, ident }) => `{ key: ${JSON.stringify(key)}, tool: ${ident} }`);
+		entryFields.push(`tools: [${toolEntries.join(", ")}]`);
+	}
+	if (skillExprs.length > 0) entryFields.push(`skills: [${skillExprs.join(", ")}]`);
+	if (inputProcessorIdents.length > 0) entryFields.push(`inputProcessors: [${inputProcessorIdents.join(", ")}]`);
+	if (outputProcessorIdents.length > 0) entryFields.push(`outputProcessors: [${outputProcessorIdents.join(", ")}]`);
+	if (scorerIdents.length > 0) {
+		const scorerEntries = scorerIdents.map(({ key, ident }) => `{ key: ${JSON.stringify(key)}, scorer: ${ident} }`);
+		entryFields.push(`scorers: [${scorerEntries.join(", ")}]`);
+	}
+	if (scheduleExprs.length > 0) entryFields.push(`schedules: [${scheduleExprs.join(", ")}]`);
+	if (subagentExprs.length > 0) entryFields.push(`subagents: [${subagentExprs.join(", ")}]`);
+	if (workspaceIdent) entryFields.push(`workspace: ${workspaceIdent}`);
+	if (memoryIdent) entryFields.push(`memory: ${memoryIdent}`);
+	entryFields.push(`defaultWorkspaceBasePath: __workspaceBasePath(${JSON.stringify(workspaceName)})`);
+	return `{ ${entryFields.join(", ")} }`;
+}
+/**
+* Generate the source of a wrapper module that:
+* 1. imports the user's real Mastra entry,
+* 2. imports each discovered `config.ts`, `instructions.ts`, `tools/*.ts`,
+*    `skills/*.ts` (`createSkill(...)` modules), `workspace.ts`, and
+*    `memory.ts`, inlining packaged `SKILL.md` skills,
+* 3. assembles `Agent` instances via `assembleAgentFromFsEntry`, wiring any
+*    declared `subagents/` into the parent (nested up to `MAX_FS_SUBAGENT_DEPTH`),
+* 4. registers them onto the user's `mastra` instance (code-registered agents
+*    win on name collisions), and
+* 5. re-exports everything from the user's entry so this module is a drop-in
+*    replacement for the original `#mastra` target.
+*
+* `instructions.md` is read into the generated wrapper. In dev, the CLI watcher
+* regenerates that wrapper when the markdown file changes. `instructions.ts` is
+* imported instead, so the bundler already tracks it through the module graph.
+*
+* @param userEntry slash-normalized absolute path to the user's mastra entry.
+* @param agents discovered fs-routed agents (absolute, slash-normalized paths).
+*/
+async function generateFsAgentsModule(userEntry, agents, options) {
+	const workflows = options?.workflows ?? [];
+	const storage = options?.storage;
+	const observability = options?.observability;
+	const logger = options?.logger;
+	const server = options?.server;
+	const studio = options?.studio;
+	const standalone = userEntry === void 0;
+	const lines = [];
+	const hasInlineSkills = (function check(list) {
+		return list.some((a) => (a.skills ?? []).some((s) => s.kind === "packaged") || check(a.subagents ?? []));
+	})(agents);
+	lines.push(`import { assembleAgentFromFsEntry } from '@mastra/core/agent';`);
+	if (hasInlineSkills) lines.push(`import { createSkill as __createSkill } from '@mastra/core/skills';`);
+	if (standalone) lines.push(`import { Mastra } from '@mastra/core';`);
+	lines.push(`import { fileURLToPath as __fileURLToPath } from 'node:url';`);
+	lines.push(`import { dirname as __dirname, join as __join } from 'node:path';`);
+	if (userEntry) {
+		lines.push(`import * as __userEntry from ${JSON.stringify(userEntry)};`);
+		lines.push(`export * from ${JSON.stringify(userEntry)};`);
+	}
+	lines.push(``);
+	lines.push(`const __bundleDir = __dirname(__fileURLToPath(import.meta.url));`);
+	lines.push(`const __workspaceBasePath = name => __join(__bundleDir, 'workspace', ...name.split('/'));`);
+	lines.push(``);
+	const singletonImports = [];
+	if (storage) singletonImports.push(`import __fsStorage from ${JSON.stringify(storage.path)};`);
+	if (observability) singletonImports.push(`import __fsObservability from ${JSON.stringify(observability.path)};`);
+	if (logger) singletonImports.push(`import __fsLogger from ${JSON.stringify(logger.path)};`);
+	if (server) singletonImports.push(`import __fsServer from ${JSON.stringify(server.path)};`);
+	if (studio) singletonImports.push(`import __fsStudio from ${JSON.stringify(studio.path)};`);
+	if (singletonImports.length > 0) {
+		lines.push(...singletonImports);
+		lines.push(``);
+	}
+	const wfCodegen = workflows.length > 0 ? generateFsWorkflowsCodegen(workflows) : void 0;
+	if (wfCodegen) {
+		for (const line of wfCodegen.importLines) lines.push(line);
+		lines.push(``);
+	}
+	const entryExprs = [];
+	for (let i = 0; i < agents.length; i++) {
+		const agent = agents[i];
+		const expr = await emitAgentEntry(agent, `${i}`, agent.name, lines);
+		entryExprs.push(expr);
+	}
+	if (standalone) {
+		lines.push(``);
+		lines.push(`const __mastra = new Mastra({});`);
+	} else {
+		lines.push(``);
+		lines.push(`const __mastra = __userEntry.mastra;`);
+	}
+	lines.push(``);
+	lines.push(`const __fsAgentEntries = [`);
+	for (const expr of entryExprs) lines.push(`  ${expr},`);
+	lines.push(`];`);
+	lines.push(``);
+	if (logger) {
+		lines.push(`if (__mastra && typeof __mastra.__registerFsLogger === 'function') {`);
+		lines.push(`  __mastra.__registerFsLogger(__fsLogger);`);
+		lines.push(`}`);
+		lines.push(``);
+	}
+	if (storage) {
+		lines.push(`if (__mastra && typeof __mastra.__registerFsStorage === 'function') {`);
+		lines.push(`  __mastra.__registerFsStorage(__fsStorage);`);
+		lines.push(`}`);
+		lines.push(``);
+	}
+	if (observability) {
+		lines.push(`if (__mastra && typeof __mastra.__registerFsObservability === 'function') {`);
+		lines.push(`  __mastra.__registerFsObservability(__fsObservability);`);
+		lines.push(`}`);
+		lines.push(``);
+	}
+	if (server) {
+		lines.push(`if (__mastra && typeof __mastra.__registerFsServer === 'function') {`);
+		lines.push(`  __mastra.__registerFsServer(__fsServer);`);
+		lines.push(`}`);
+		lines.push(``);
+	}
+	if (studio) {
+		lines.push(`if (__mastra && typeof __mastra.__registerFsStudio === 'function') {`);
+		lines.push(`  __mastra.__registerFsStudio(__fsStudio);`);
+		lines.push(`}`);
+		lines.push(``);
+	}
+	lines.push(`const __fsAgents = Object.create(null);`);
+	lines.push(`for (const __entry of __fsAgentEntries) {`);
+	lines.push(`  __fsAgents[__entry.name] = assembleAgentFromFsEntry(__entry, {`);
+	lines.push(`    onWarn: msg => __mastra?.getLogger?.()?.warn?.(msg) ?? console.warn(msg),`);
+	lines.push(`  });`);
+	lines.push(`}`);
+	lines.push(``);
+	lines.push(`if (__mastra && typeof __mastra.__registerFsAgents === 'function') {`);
+	lines.push(`  __mastra.__registerFsAgents(__fsAgents);`);
+	lines.push(`}`);
+	if (wfCodegen) {
+		lines.push(``);
+		for (const line of wfCodegen.registrationLines) lines.push(line);
+	}
+	lines.push(``);
+	lines.push(`export const mastra = __mastra;`);
+	return lines.join("\n");
+}
+/**
+* Generate the workflow-registration lines to splice into the generated wrapper
+* module. Emits import statements for each discovered workflow module and a
+* registration block that calls `__registerFsWorkflows` on the user's mastra.
+*
+* Returns `{ importLines, registrationLines }` so the caller can place them at
+* the correct positions in the wrapper source.
+*/
+function generateFsWorkflowsCodegen(workflows) {
+	const importLines = [];
+	const registrationLines = [];
+	for (let i = 0; i < workflows.length; i++) {
+		const wf = workflows[i];
+		const ident = sanitizeIdentifier(wf.key, "workflow", `${i}`);
+		importLines.push(`import ${ident} from ${JSON.stringify(wf.path)};`);
+	}
+	registrationLines.push(`const __fsWorkflows = Object.create(null);`);
+	for (let i = 0; i < workflows.length; i++) {
+		const wf = workflows[i];
+		const ident = sanitizeIdentifier(wf.key, "workflow", `${i}`);
+		registrationLines.push(`__fsWorkflows[${JSON.stringify(wf.key)}] = ${ident};`);
+	}
+	registrationLines.push(``);
+	registrationLines.push(`if (__mastra && typeof __mastra.__registerFsWorkflows === 'function') {`);
+	registrationLines.push(`  __mastra.__registerFsWorkflows(__fsWorkflows);`);
+	registrationLines.push(`}`);
+	return {
+		importLines,
+		registrationLines
+	};
+}
+//#endregion
+//#region src/build/fs-routing/prepare.ts
+/**
+* Discover fs-routed agents under `<mastraDir>/agents/*`, workflows under
+* `<mastraDir>/workflows/`, and singleton config files (e.g. `storage.ts`,
+* `observability.ts`, `logger.ts`, `server.ts`, `studio.ts`).
+* When any are found, generate a wrapper entry module that registers them onto
+* the user's mastra instance. Returns the entry the bundler should use plus
+* extra tool glob paths so `agents/*\/tools` are bundled.
+*
+* This does NOT write the wrapper to disk; call {@link writeFsAgentsEntry} with
+* the result after `bundler.prepare()` so the generated file is not wiped when
+* the output directory is emptied.
+*
+* When `entryFile` is `undefined` (no `index.ts`/`index.js`) and fs-routed
+* primitives are found, a standalone Mastra instance is auto-constructed from
+* them — no user code required.
+*
+* When no fs-routed primitives are present the original entry is returned
+* unchanged, so existing code-only projects are completely unaffected.
+*/
+async function prepareFsAgentsEntry(mastraDir, entryFile, outputDirectory) {
+	const [agents, workflows, storage, observability, logger, server, studio] = await Promise.all([
+		discoverFsAgents(mastraDir),
+		discoverFsWorkflows(mastraDir),
+		discoverFsSingleton(mastraDir, "storage"),
+		discoverFsSingleton(mastraDir, "observability"),
+		discoverFsSingleton(mastraDir, "logger"),
+		discoverFsSingleton(mastraDir, "server"),
+		discoverFsSingleton(mastraDir, "studio")
+	]);
+	const standalone = entryFile === void 0;
+	const hasFsPrimitives = agents.length > 0 || workflows.length > 0 || !!storage || !!observability || !!logger || !!server || !!studio;
+	if (!hasFsPrimitives && entryFile !== void 0) return {
+		entryFile,
+		standalone: false,
+		toolPaths: [],
+		agentCount: 0,
+		workflowCount: 0,
+		hasStorage: false,
+		hasObservability: false,
+		hasLogger: false,
+		hasServer: false,
+		hasStudio: false
+	};
+	if (!hasFsPrimitives && standalone) throw new Error("No index.ts and no file-based primitives found. Create src/mastra/index.ts with a Mastra instance, or add file-based agents/workflows/storage.");
+	const moduleSource = await generateFsAgentsModule(entryFile ? require_utils.slash(entryFile) : void 0, agents, {
+		workflows,
+		storage,
+		observability,
+		logger,
+		server,
+		studio
+	});
+	const generatedEntry = (0, path.join)(outputDirectory, ".mastra-fs-agents-entry.mjs");
+	const normalizedMastraDir = require_utils.slash(mastraDir);
+	return {
+		entryFile: generatedEntry,
+		standalone,
+		toolPaths: agents.length > 0 ? [
+			path.posix.join(normalizedMastraDir, "agents/*/tools/**/*.{js,ts}"),
+			`!${path.posix.join(normalizedMastraDir, "agents/*/tools/**/*.{test,spec}.{js,ts}")}`,
+			`!${path.posix.join(normalizedMastraDir, "agents/*/tools/**/__tests__/**")}`
+		] : [],
+		agentCount: agents.length,
+		workflowCount: workflows.length,
+		hasStorage: !!storage,
+		hasObservability: !!observability,
+		hasLogger: !!logger,
+		hasServer: !!server,
+		hasStudio: !!studio,
+		moduleSource
+	};
+}
+/**
+* Write the generated fs-agents wrapper produced by {@link prepareFsAgentsEntry}
+* to its `entryFile`. No-op when there are no fs-routed agents. Call this AFTER
+* `bundler.prepare()` (which empties the output directory) so the wrapper
+* survives for the bundler/watcher to read.
+*/
+async function writeFsAgentsEntry(result) {
+	if (!result.moduleSource) return;
+	await (0, fs_promises.mkdir)((0, path.dirname)(result.entryFile), { recursive: true });
+	await (0, fs_promises.writeFile)(result.entryFile, result.moduleSource, "utf-8");
+}
+//#endregion
+//#region src/build/fs-routing/mirror.ts
+/**
+* Skip symlinks when copying workspace seeds. A symlink under
+* `agents/<name>/workspace/` could point outside the workspace and be preserved
+* in the bundle, letting the agent read arbitrary files at runtime. We copy only
+* regular files and directories.
+*/
+async function rejectSymlinks(source) {
+	return !(await (0, fs_promises.lstat)(source)).isSymbolicLink();
+}
+async function mirrorAgentSeeds(agent, workspaceName, bundleDir, mirrored) {
+	if (agent.workspaceSeedDir) {
+		const destination = (0, path.join)(bundleDir, "workspace", ...workspaceName.split("/"));
+		await (0, fs_promises.mkdir)(destination, { recursive: true });
+		await (0, fs_promises.cp)(agent.workspaceSeedDir, destination, {
+			recursive: true,
+			filter: rejectSymlinks
+		});
+		mirrored.push(workspaceName);
+	}
+	for (const child of agent.subagents ?? []) await mirrorAgentSeeds(child, `${workspaceName}/${child.name}`, bundleDir, mirrored);
+}
+/**
+* Mirror authored `agents/<name>/workspace/**` seed files into the bundled
+* output so each fs-routed agent starts with them on disk (Eve parity). Files
+* are copied to `<bundleDir>/workspace/<name>`, which is exactly where the
+* generated entry roots each agent's default workspace at runtime (resolved
+* relative to the bundled module via `import.meta.url`). Declared subagents
+* mirror to the nested `<bundleDir>/workspace/<parent>/<child>` path.
+*
+* Must run AFTER the bundle step, since bundling recreates the output dir.
+*
+* @param mastraDir   The user's `src/mastra` directory (source of seeds).
+* @param bundleDir   The final bundle directory (e.g. `<outputDirectory>/output`).
+* @returns the workspace names whose seeds were mirrored (`<parent>/<child>` for subagents).
+*/
+async function mirrorFsAgentWorkspaces(mastraDir, bundleDir) {
+	const agents = await discoverFsAgents(mastraDir);
+	const mirrored = [];
+	for (const agent of agents) await mirrorAgentSeeds(agent, agent.name, bundleDir, mirrored);
+	return mirrored;
+}
+//#endregion
+Object.defineProperty(exports, "analyzeEntryProjectType", {
+	enumerable: true,
+	get: function() {
+		return analyzeEntryProjectType;
+	}
+});
+Object.defineProperty(exports, "createWatcher", {
+	enumerable: true,
+	get: function() {
+		return createWatcher;
+	}
+});
+Object.defineProperty(exports, "discoverFsAgents", {
+	enumerable: true,
+	get: function() {
+		return discoverFsAgents;
+	}
+});
+Object.defineProperty(exports, "discoverFsSingleton", {
+	enumerable: true,
+	get: function() {
+		return discoverFsSingleton;
+	}
+});
+Object.defineProperty(exports, "discoverFsWorkflows", {
+	enumerable: true,
+	get: function() {
+		return discoverFsWorkflows;
+	}
+});
+Object.defineProperty(exports, "generateFsAgentsModule", {
+	enumerable: true,
+	get: function() {
+		return generateFsAgentsModule;
+	}
+});
+Object.defineProperty(exports, "generateFsWorkflowsCodegen", {
+	enumerable: true,
+	get: function() {
+		return generateFsWorkflowsCodegen;
+	}
+});
+Object.defineProperty(exports, "getInputOptions", {
+	enumerable: true,
+	get: function() {
+		return getInputOptions;
+	}
+});
+Object.defineProperty(exports, "getServerOptions", {
+	enumerable: true,
+	get: function() {
+		return getServerOptions;
+	}
+});
+Object.defineProperty(exports, "mirrorFsAgentWorkspaces", {
+	enumerable: true,
+	get: function() {
+		return mirrorFsAgentWorkspaces;
+	}
+});
+Object.defineProperty(exports, "prepareFsAgentsEntry", {
+	enumerable: true,
+	get: function() {
+		return prepareFsAgentsEntry;
+	}
+});
+Object.defineProperty(exports, "writeFsAgentsEntry", {
+	enumerable: true,
+	get: function() {
+		return writeFsAgentsEntry;
+	}
+});
+
+//# sourceMappingURL=build-YV8-9zZy.cjs.map