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

package/dist/build-KCOeHd4N.js

@@ -0,0 +1,834 @@
+import { i as getWorkspaceInformation, n as checkConfigExport, r as aliasHono, t as analyzeBundle } from "./analyze-C2q7jxbN.js";
+import { a as getPackageName, p as slash } from "./utils-FVOUvj-I.js";
+import "./services-CLi56qqe.js";
+import { a as tsConfigPaths, l as nodeModulesExtensionResolver, n as getInputOptions$1 } from "./bundler-D86rFu2J.js";
+import { n as extractMastraOption } from "./bundlerOptions-aFsEi86t.js";
+import { cp, lstat, mkdir, readFile, readdir, writeFile } from "fs/promises";
+import { dirname, join, posix } from "path";
+import * as pkg from "empathic/package";
+import { transformAsync } from "@babel/core";
+import { watch } from "rollup";
+import { noopLogger } from "@mastra/core/logger";
+import { MAX_FS_SUBAGENT_DEPTH } from "@mastra/core/agent";
+import matter from "gray-matter";
+//#region src/build/watcher.ts
+async function getInputOptions(entryFile, platform, env, { sourcemap = false, bundlerOptions = {
+	enableSourcemap: false,
+	enableEsmShim: true,
+	externals: true
+}, analysisEntries = [entryFile] } = {}) {
+	const closestPkgJson = pkg.up({ cwd: dirname(entryFile) });
+	const projectRoot = closestPkgJson ? dirname(slash(closestPkgJson)) : slash(process.cwd());
+	const { workspaceMap, workspaceRoot } = await getWorkspaceInformation({ mastraEntryFile: entryFile });
+	const analyzeEntryResult = await analyzeBundle(analysisEntries, entryFile, {
+		outputDir: posix.join(process.cwd(), ".mastra", ".build"),
+		projectRoot: workspaceRoot || process.cwd(),
+		platform,
+		isDev: true,
+		bundlerOptions
+	}, noopLogger);
+	const deps = /* @__PURE__ */ new Map();
+	for (const [dep, metadata] of analyzeEntryResult.dependencies.entries()) {
+		const pkgName = getPackageName(dep);
+		if (pkgName && workspaceMap.has(pkgName)) deps.set(dep, metadata);
+	}
+	const inputOptions = await getInputOptions$1(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(tsConfigPaths({ localResolve: true }));
+				return;
+			}
+			plugins.push(plugin);
+		});
+		inputOptions.plugins = plugins;
+		inputOptions.plugins.push(aliasHono());
+		inputOptions.plugins.push(nodeModulesExtensionResolver());
+	}
+	return inputOptions;
+}
+async function createWatcher(inputOptions, outputOptions) {
+	return await 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 readFile(mastraEntry, "utf-8");
+	const result = { hasValidConfig: false };
+	await transformAsync(code, {
+		filename: mastraEntry,
+		presets: [import.meta.resolve("@babel/preset-typescript")],
+		plugins: [() => checkConfigExport(result)]
+	});
+	return result.projectType;
+}
+//#endregion
+//#region src/build/serverOptions.ts
+async function getServerOptions(entryFile, outputDir, logger) {
+	const result = await extractMastraOption("server", entryFile, outputDir, logger);
+	if (!result) return null;
+	return result.getConfig();
+}
+//#endregion
+//#region src/build/fs-routing/discover.ts
+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 TOOL_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`/`workspace.ts`/
+* `memory.ts` is never inlined or imported into the generated bundle.
+*/
+async function exists(path) {
+	try {
+		return !(await lstat(path)).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) {
+	try {
+		const info = await lstat(path);
+		if (info.isDirectory() && !info.isSymbolicLink()) return slash(path);
+	} catch {}
+}
+async function directoryExists(path) {
+	return realDirectory(path);
+}
+async function firstExisting(dir, basenames) {
+	for (const basename of basenames) {
+		const candidate = join(dir, basename);
+		if (await exists(candidate)) return 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 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 = join(dir, basename);
+		const stats = await lstat(path);
+		if (stats.isSymbolicLink() || stats.isDirectory()) continue;
+		modules.push({
+			key: toolKey(basename),
+			path: slash(path)
+		});
+	}
+	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 = join(processorsDir, type);
+		if (!await exists(typeDir)) continue;
+		let entries;
+		try {
+			entries = await 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 = join(typeDir, basename);
+			const stats = await lstat(path);
+			if (stats.isSymbolicLink() || stats.isDirectory()) continue;
+			result[type].push({
+				key: toolKey(basename),
+				path: slash(path)
+			});
+		}
+	}
+	return result;
+}
+async function readReferences(referencesDir) {
+	if (!await exists(referencesDir)) return {};
+	const references = {};
+	let entries;
+	try {
+		entries = await readdir(referencesDir);
+	} catch {
+		return {};
+	}
+	for (const basename of entries.sort()) {
+		const path = join(referencesDir, basename);
+		const stats = await lstat(path);
+		if (stats.isSymbolicLink() || stats.isDirectory()) continue;
+		references[basename] = await readFile(path, "utf-8");
+	}
+	return references;
+}
+async function parsePackagedSkill(skillMdPath, fallbackName, references = {}) {
+	const parsed = matter(await 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 readdir(skillsDir);
+	} catch {
+		return [];
+	}
+	const skills = [];
+	for (const basename of entries.sort()) {
+		if (isTestFile(basename)) continue;
+		const path = join(skillsDir, basename);
+		const stats = await lstat(path);
+		if (stats.isSymbolicLink()) continue;
+		if (stats.isDirectory()) {
+			const skillMd = join(path, SKILL_MD_BASENAME);
+			if (await exists(skillMd)) {
+				const references = await readReferences(join(path, "references"));
+				skills.push(await parsePackagedSkill(skillMd, skillModuleName(basename), references));
+			}
+			continue;
+		}
+		if (SKILL_MODULE_EXTENSIONS.some((ext) => basename.endsWith(ext))) {
+			skills.push({
+				kind: "module",
+				path: slash(path)
+			});
+			continue;
+		}
+		if (basename.endsWith(".md")) {
+			const skill = await parsePackagedSkill(path, basename.replace(/\.md$/, ""));
+			skills.push(skill);
+		}
+	}
+	return skills;
+}
+/**
+* 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)` and no
+* `instructions.md`).
+*
+* `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(join(dir, INSTRUCTIONS_BASENAME)) ? slash(join(dir, INSTRUCTIONS_BASENAME)) : void 0;
+	if (!configPath && !instructionsPath) return;
+	const workspacePath = await firstExisting(dir, WORKSPACE_BASENAMES);
+	const memoryPath = await firstExisting(dir, MEMORY_BASENAMES);
+	const workspaceSeedDir = await directoryExists(join(dir, "workspace"));
+	const tools = await discoverTools(join(dir, "tools"));
+	const processors = await discoverProcessors(join(dir, "processors"));
+	const scorers = await discoverModuleDir(join(dir, "scorers"));
+	const skills = await discoverSkills(join(dir, "skills"));
+	const subagents = await discoverSubagents(dir, depth, onWarn);
+	return {
+		name,
+		dir: slash(dir),
+		configPath,
+		instructionsPath,
+		workspacePath,
+		memoryPath,
+		workspaceSeedDir,
+		tools,
+		inputProcessors: processors.input,
+		outputProcessors: processors.output,
+		scorers,
+		skills,
+		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 = join(parentDir, "subagents");
+	if (!await exists(subagentsDir)) return [];
+	if (parentDepth >= MAX_FS_SUBAGENT_DEPTH) {
+		onWarn?.(`Ignoring subagents in "${slash(subagentsDir)}": subagents may only nest ${MAX_FS_SUBAGENT_DEPTH} levels below a top-level agent.`);
+		return [];
+	}
+	let entries;
+	try {
+		entries = await readdir(subagentsDir);
+	} catch {
+		return [];
+	}
+	const subagents = [];
+	for (const name of entries.sort()) {
+		const dir = 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)` or an
+* `instructions.md`; 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 = join(mastraDir, "agents");
+	if (!await exists(agentsDir)) return [];
+	let entries;
+	try {
+		entries = await readdir(agentsDir);
+	} catch {
+		return [];
+	}
+	const discovered = [];
+	for (const name of entries.sort()) {
+		const dir = 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 = join(mastraDir, "workflows");
+	if (!await exists(workflowsDir)) return [];
+	let entries;
+	try {
+		entries = await 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 = join(workflowsDir, basename);
+		const stats = await lstat(path);
+		if (stats.isSymbolicLink() || stats.isDirectory()) continue;
+		const source = await readFile(path, "utf-8");
+		if (!/\bexport\s+default\b/.test(source)) continue;
+		discovered.push({
+			key: toolKey(basename),
+			path: slash(path)
+		});
+	}
+	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 = join(mastraDir, `${name}${ext}`);
+		try {
+			const stats = await lstat(candidate);
+			if (!stats.isFile() || stats.isSymbolicLink()) continue;
+			const source = await readFile(candidate, "utf-8");
+			if (!/\bexport\s+default\b/.test(source)) continue;
+			return { path: 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)};`);
+	}
+	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(", ")} })`);
+		}
+	}
+	let instructionsMd;
+	if (agent.instructionsPath) instructionsMd = await 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 (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 (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`, `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.
+*
+* @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(``);
+	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(``);
+	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(`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 ? slash(entryFile) : void 0, agents, {
+		workflows,
+		storage,
+		observability,
+		logger,
+		server,
+		studio
+	});
+	const generatedEntry = join(outputDirectory, ".mastra-fs-agents-entry.mjs");
+	const normalizedMastraDir = slash(mastraDir);
+	return {
+		entryFile: generatedEntry,
+		standalone,
+		toolPaths: agents.length > 0 ? [
+			posix.join(normalizedMastraDir, "agents/*/tools/**/*.{js,ts}"),
+			`!${posix.join(normalizedMastraDir, "agents/*/tools/**/*.{test,spec}.{js,ts}")}`,
+			`!${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 mkdir(dirname(result.entryFile), { recursive: true });
+	await 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 lstat(source)).isSymbolicLink();
+}
+async function mirrorAgentSeeds(agent, workspaceName, bundleDir, mirrored) {
+	if (agent.workspaceSeedDir) {
+		const destination = join(bundleDir, "workspace", ...workspaceName.split("/"));
+		await mkdir(destination, { recursive: true });
+		await 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
+export { generateFsWorkflowsCodegen as a, discoverFsWorkflows as c, createWatcher as d, getInputOptions as f, generateFsAgentsModule as i, getServerOptions as l, prepareFsAgentsEntry as n, discoverFsAgents as o, writeFsAgentsEntry as r, discoverFsSingleton as s, mirrorFsAgentWorkspaces as t, analyzeEntryProjectType as u };
+
+//# sourceMappingURL=build-KCOeHd4N.js.map