@mastra/temporal 0.2.11-alpha.0 → 0.2.11-alpha.2

package/dist/worker.js

@@ -1,485 +1,321 @@
-import { toWorkflowType } from './chunk-BF6TR7JX.js';
-import { readFileSync } from 'fs';
-import { writeFile } from 'fs/promises';
-import path, { basename, join } from 'path';
-import { fileURLToPath, pathToFileURL } from 'url';
-import { generate } from '@babel/generator';
-import { parse } from '@babel/parser';
-import * as t3 from '@babel/types';
-import { rollup } from 'rollup';
-
-var parserPlugins = ["typescript", "jsx", "decorators-legacy"];
+import { t as toWorkflowType } from "./utils-B_iPTfDi.js";
+import { readFileSync } from "fs";
+import { writeFile } from "fs/promises";
+import path, { basename, join } from "path";
+import { fileURLToPath, pathToFileURL } from "url";
+import { generate } from "@babel/generator";
+import { parse } from "@babel/parser";
+import * as t from "@babel/types";
+import { rollup } from "rollup";
+//#region src/transforms/shared.ts
+const parserPlugins = [
+	"typescript",
+	"jsx",
+	"decorators-legacy"
+];
 function parseModule(filePath, sourceText) {
-  if (!sourceText) {
-    sourceText = readFileSync(filePath, "utf8");
-  }
-  return parse(sourceText, {
-    sourceType: "module",
-    plugins: parserPlugins,
-    sourceFilename: filePath
-  });
+	if (!sourceText) sourceText = readFileSync(filePath, "utf8");
+	return parse(sourceText, {
+		sourceType: "module",
+		plugins: parserPlugins,
+		sourceFilename: filePath
+	});
 }
 function isIdentifierNamed(node, name) {
-  return t3.isIdentifier(node) && node.name === name;
+	return t.isIdentifier(node) && node.name === name;
 }
 function isTemporalHelperModule(source) {
-  return typeof source === "string" && /(^|\/)temporal\.(ts|tsx|js|jsx|mts|mjs)$/.test(source);
+	return typeof source === "string" && /(^|\/)temporal\.(ts|tsx|js|jsx|mts|mjs)$/.test(source);
 }
-var strippedExternalModules = /* @__PURE__ */ new Set(["@temporalio/client", "@temporalio/envconfig"]);
+const strippedExternalModules = /* @__PURE__ */ new Set(["@temporalio/client", "@temporalio/envconfig"]);
 function isStrippedExternalModule(source) {
-  return typeof source === "string" && strippedExternalModules.has(source);
+	return typeof source === "string" && strippedExternalModules.has(source);
 }
 function collectImportedNames(statement) {
-  const names = /* @__PURE__ */ new Set();
-  for (const specifier of statement.specifiers) {
-    if (t3.isImportDefaultSpecifier(specifier) || t3.isImportNamespaceSpecifier(specifier) || t3.isImportSpecifier(specifier)) {
-      if (t3.isIdentifier(specifier.local)) {
-        names.add(specifier.local.name);
-      }
-    }
-  }
-  return names;
+	const names = /* @__PURE__ */ new Set();
+	for (const specifier of statement.specifiers) if (t.isImportDefaultSpecifier(specifier) || t.isImportNamespaceSpecifier(specifier) || t.isImportSpecifier(specifier)) {
+		if (t.isIdentifier(specifier.local)) names.add(specifier.local.name);
+	}
+	return names;
 }
 function nodeReferencesName(node, names) {
-  let found = false;
-  walk(node, (current) => {
-    if (t3.isIdentifier(current) && names.has(current.name)) {
-      found = true;
-      return false;
-    }
-  });
-  return found;
+	let found = false;
+	walk(node, (current) => {
+		if (t.isIdentifier(current) && names.has(current.name)) {
+			found = true;
+			return false;
+		}
+	});
+	return found;
 }
 function isWorkflowHelperDestructure(declaration) {
-  if (!t3.isObjectPattern(declaration.id)) {
-    return false;
-  }
-  return declaration.id.properties.some(
-    (property) => t3.isObjectProperty(property) && !property.computed && t3.isIdentifier(property.value) && (property.value.name === "createStep" || property.value.name === "createWorkflow")
-  );
+	if (!t.isObjectPattern(declaration.id)) return false;
+	return declaration.id.properties.some((property) => t.isObjectProperty(property) && !property.computed && t.isIdentifier(property.value) && (property.value.name === "createStep" || property.value.name === "createWorkflow"));
 }
 function isCreateWorkflowCall(node) {
-  return t3.isCallExpression(node) && isIdentifierNamed(node.callee, "createWorkflow");
+	return t.isCallExpression(node) && isIdentifierNamed(node.callee, "createWorkflow");
 }
 function isCreateStepCall(node) {
-  return t3.isCallExpression(node) && isIdentifierNamed(node.callee, "createStep");
+	return t.isCallExpression(node) && isIdentifierNamed(node.callee, "createStep");
 }
 function getObjectPropertyName(property) {
-  if (property.computed) {
-    return null;
-  }
-  if (t3.isIdentifier(property.key)) {
-    return property.key.name;
-  }
-  if (t3.isStringLiteral(property.key)) {
-    return property.key.value;
-  }
-  return null;
+	if (property.computed) return null;
+	if (t.isIdentifier(property.key)) return property.key.name;
+	if (t.isStringLiteral(property.key)) return property.key.value;
+	return null;
 }
 function walk(node, visitor) {
-  if (!node) {
-    return;
-  }
-  const result = visitor(node);
-  if (result === false) {
-    return;
-  }
-  const keys = t3.VISITOR_KEYS[node.type] ?? [];
-  for (const key of keys) {
-    const value = node[key];
-    if (Array.isArray(value)) {
-      for (const child of value) {
-        if (child && typeof child.type === "string") {
-          walk(child, visitor);
-        }
-      }
-      continue;
-    }
-    if (value && typeof value.type === "string") {
-      walk(value, visitor);
-    }
-  }
+	if (!node) return;
+	if (visitor(node) === false) return;
+	const keys = t.VISITOR_KEYS[node.type] ?? [];
+	for (const key of keys) {
+		const value = node[key];
+		if (Array.isArray(value)) {
+			for (const child of value) if (child && typeof child.type === "string") walk(child, visitor);
+			continue;
+		}
+		if (value && typeof value.type === "string") walk(value, visitor);
+	}
 }
 function hasCreateWorkflowCall(node) {
-  let found = false;
-  walk(node, (current) => {
-    if (isCreateWorkflowCall(current)) {
-      found = true;
-      return false;
-    }
-  });
-  return found;
+	let found = false;
+	walk(node, (current) => {
+		if (isCreateWorkflowCall(current)) {
+			found = true;
+			return false;
+		}
+	});
+	return found;
 }
 function getStepNameFromCall(node) {
-  const stepId = getCreateStepId(node);
-  if (!stepId) {
-    return null;
-  }
-  return stepId.replace(/[^a-zA-Z0-9]+(.)/g, (_match, char) => char.toUpperCase()).replace(/^[^a-zA-Z_$]+/, "").replace(/^(.)/, (char) => char.toLowerCase());
+	const stepId = getCreateStepId(node);
+	if (!stepId) return null;
+	return stepId.replace(/[^a-zA-Z0-9]+(.)/g, (_match, char) => char.toUpperCase()).replace(/^[^a-zA-Z_$]+/, "").replace(/^(.)/, (char) => char.toLowerCase());
 }
 function createExportedStepStatement(name, initializer) {
-  return t3.exportNamedDeclaration(
-    t3.variableDeclaration("const", [t3.variableDeclarator(t3.identifier(name), t3.cloneNode(initializer, true))])
-  );
+	return t.exportNamedDeclaration(t.variableDeclaration("const", [t.variableDeclarator(t.identifier(name), t.cloneNode(initializer, true))]));
 }
 function collectInlineCreateSteps(node, seenNames, statements, onStep) {
-  walk(node, (current) => {
-    if (!isCreateStepCall(current)) {
-      return;
-    }
-    const stepName = getStepNameFromCall(current);
-    if (!stepName || seenNames.has(stepName)) {
-      return false;
-    }
-    seenNames.add(stepName);
-    onStep?.(stepName, current);
-    statements.push(createExportedStepStatement(stepName, current));
-    return false;
-  });
+	walk(node, (current) => {
+		if (!isCreateStepCall(current)) return;
+		const stepName = getStepNameFromCall(current);
+		if (!stepName || seenNames.has(stepName)) return false;
+		seenNames.add(stepName);
+		onStep?.(stepName, current);
+		statements.push(createExportedStepStatement(stepName, current));
+		return false;
+	});
 }
 function getReturnedCreateStepCall(node) {
-  if (!node) {
-    return null;
-  }
-  if (t3.isArrowFunctionExpression(node) && !t3.isBlockStatement(node.body)) {
-    return t3.isCallExpression(node.body) && isIdentifierNamed(node.body.callee, "createStep") ? node.body : null;
-  }
-  if (!t3.isFunctionDeclaration(node) && !t3.isFunctionExpression(node) && !t3.isArrowFunctionExpression(node)) {
-    return null;
-  }
-  if (!t3.isBlockStatement(node.body)) {
-    return null;
-  }
-  for (const statement of node.body.body) {
-    if (t3.isReturnStatement(statement) && t3.isCallExpression(statement.argument) && isIdentifierNamed(statement.argument.callee, "createStep")) {
-      return statement.argument;
-    }
-  }
-  return null;
+	if (!node) return null;
+	if (t.isArrowFunctionExpression(node) && !t.isBlockStatement(node.body)) return t.isCallExpression(node.body) && isIdentifierNamed(node.body.callee, "createStep") ? node.body : null;
+	if (!t.isFunctionDeclaration(node) && !t.isFunctionExpression(node) && !t.isArrowFunctionExpression(node)) return null;
+	if (!t.isBlockStatement(node.body)) return null;
+	for (const statement of node.body.body) if (t.isReturnStatement(statement) && t.isCallExpression(statement.argument) && isIdentifierNamed(statement.argument.callee, "createStep")) return statement.argument;
+	return null;
 }
-function collectCreateStepFactoryBindings(program3) {
-  const factories = /* @__PURE__ */ new Map();
-  for (const statement of program3.body) {
-    const declaration = t3.isExportNamedDeclaration(statement) ? statement.declaration : statement;
-    if (t3.isFunctionDeclaration(declaration) && declaration.id) {
-      const createStepCall = getReturnedCreateStepCall(declaration);
-      if (createStepCall) {
-        factories.set(declaration.id.name, createStepCall);
-      }
-      continue;
-    }
-    if (!t3.isVariableDeclaration(declaration)) {
-      continue;
-    }
-    for (const declarator of declaration.declarations) {
-      if (!t3.isIdentifier(declarator.id) || !declarator.init) {
-        continue;
-      }
-      const createStepCall = getReturnedCreateStepCall(declarator.init);
-      if (createStepCall) {
-        factories.set(declarator.id.name, createStepCall);
-      }
-    }
-  }
-  return factories;
+function collectCreateStepFactoryBindings(program) {
+	const factories = /* @__PURE__ */ new Map();
+	for (const statement of program.body) {
+		const declaration = t.isExportNamedDeclaration(statement) ? statement.declaration : statement;
+		if (t.isFunctionDeclaration(declaration) && declaration.id) {
+			const createStepCall = getReturnedCreateStepCall(declaration);
+			if (createStepCall) factories.set(declaration.id.name, createStepCall);
+			continue;
+		}
+		if (!t.isVariableDeclaration(declaration)) continue;
+		for (const declarator of declaration.declarations) {
+			if (!t.isIdentifier(declarator.id) || !declarator.init) continue;
+			const createStepCall = getReturnedCreateStepCall(declarator.init);
+			if (createStepCall) factories.set(declarator.id.name, createStepCall);
+		}
+	}
+	return factories;
 }
 function getCreateStepCallFromExpression(node, factoryBindings) {
-  if (!node) {
-    return null;
-  }
-  if (t3.isCallExpression(node)) {
-    if (isIdentifierNamed(node.callee, "createStep")) {
-      return node;
-    }
-    if (t3.isIdentifier(node.callee)) {
-      return factoryBindings.get(node.callee.name) ?? null;
-    }
-  }
-  const returnedCreateStepCall = getReturnedCreateStepCall(node);
-  if (returnedCreateStepCall) {
-    return returnedCreateStepCall;
-  }
-  return null;
+	if (!node) return null;
+	if (t.isCallExpression(node)) {
+		if (isIdentifierNamed(node.callee, "createStep")) return node;
+		if (t.isIdentifier(node.callee)) return factoryBindings.get(node.callee.name) ?? null;
+	}
+	const returnedCreateStepCall = getReturnedCreateStepCall(node);
+	if (returnedCreateStepCall) return returnedCreateStepCall;
+	return null;
 }
 function getCreateStepId(node) {
-  if (!node || !isCreateStepCall(node)) {
-    return null;
-  }
-  const [config] = node.arguments;
-  if (!t3.isObjectExpression(config)) {
-    return null;
-  }
-  for (const property of config.properties) {
-    if (!t3.isObjectProperty(property) && !t3.isObjectMethod(property)) {
-      continue;
-    }
-    if (getObjectPropertyName(property) !== "id") {
-      continue;
-    }
-    const value = t3.isObjectMethod(property) ? null : property.value;
-    return t3.isStringLiteral(value) ? value.value : null;
-  }
-  return null;
+	if (!node || !isCreateStepCall(node)) return null;
+	const [config] = node.arguments;
+	if (!t.isObjectExpression(config)) return null;
+	for (const property of config.properties) {
+		if (!t.isObjectProperty(property) && !t.isObjectMethod(property)) continue;
+		if (getObjectPropertyName(property) !== "id") continue;
+		const value = t.isObjectMethod(property) ? null : property.value;
+		return t.isStringLiteral(value) ? value.value : null;
+	}
+	return null;
 }
 function shouldCountIdentifierAsReference(parent, key) {
-  if (!parent) {
-    return true;
-  }
-  if ((t3.isObjectProperty(parent) || t3.isObjectMethod(parent)) && key === "key" && !parent.computed) {
-    return false;
-  }
-  if (t3.isMemberExpression(parent) && key === "property" && !parent.computed) {
-    return false;
-  }
-  if (t3.isVariableDeclarator(parent) && key === "id") {
-    return false;
-  }
-  if ((t3.isFunctionDeclaration(parent) || t3.isFunctionExpression(parent) || t3.isArrowFunctionExpression(parent)) && key === "params") {
-    return false;
-  }
-  if ((t3.isFunctionDeclaration(parent) || t3.isFunctionExpression(parent) || t3.isClassDeclaration(parent)) && key === "id") {
-    return false;
-  }
-  if ((t3.isImportSpecifier(parent) || t3.isImportDefaultSpecifier(parent) || t3.isImportNamespaceSpecifier(parent)) && (key === "local" || key === "imported")) {
-    return false;
-  }
-  if (t3.isExportSpecifier(parent) && key === "exported") {
-    return false;
-  }
-  if (t3.isLabeledStatement(parent) && key === "label") {
-    return false;
-  }
-  if (t3.isCatchClause(parent) && key === "param") {
-    return false;
-  }
-  if (t3.isRestElement(parent) && key === "argument") {
-    return false;
-  }
-  if (t3.isAssignmentPattern(parent) && key === "left") {
-    return false;
-  }
-  if (t3.isTSPropertySignature(parent) || t3.isTSMethodSignature(parent) || t3.isTSInterfaceHeritage(parent)) {
-    return false;
-  }
-  return true;
+	if (!parent) return true;
+	if ((t.isObjectProperty(parent) || t.isObjectMethod(parent)) && key === "key" && !parent.computed) return false;
+	if (t.isMemberExpression(parent) && key === "property" && !parent.computed) return false;
+	if (t.isVariableDeclarator(parent) && key === "id") return false;
+	if ((t.isFunctionDeclaration(parent) || t.isFunctionExpression(parent) || t.isArrowFunctionExpression(parent)) && key === "params") return false;
+	if ((t.isFunctionDeclaration(parent) || t.isFunctionExpression(parent) || t.isClassDeclaration(parent)) && key === "id") return false;
+	if ((t.isImportSpecifier(parent) || t.isImportDefaultSpecifier(parent) || t.isImportNamespaceSpecifier(parent)) && (key === "local" || key === "imported")) return false;
+	if (t.isExportSpecifier(parent) && key === "exported") return false;
+	if (t.isLabeledStatement(parent) && key === "label") return false;
+	if (t.isCatchClause(parent) && key === "param") return false;
+	if (t.isRestElement(parent) && key === "argument") return false;
+	if (t.isAssignmentPattern(parent) && key === "left") return false;
+	if (t.isTSPropertySignature(parent) || t.isTSMethodSignature(parent) || t.isTSInterfaceHeritage(parent)) return false;
+	return true;
 }
 function collectRuntimeReferencedIdentifiers(node) {
-  const refs = /* @__PURE__ */ new Set();
-  const visit = (current, parent, key) => {
-    if (!current) {
-      return;
-    }
-    if (current.type.startsWith("TS")) {
-      return;
-    }
-    if (t3.isIdentifier(current)) {
-      if (shouldCountIdentifierAsReference(parent, key)) {
-        refs.add(current.name);
-      }
-      return;
-    }
-    for (const visitorKey of t3.VISITOR_KEYS[current.type] ?? []) {
-      const value = current[visitorKey];
-      if (Array.isArray(value)) {
-        value.forEach((child) => {
-          if (t3.isNode(child)) {
-            visit(child, current, visitorKey);
-          }
-        });
-        continue;
-      }
-      if (t3.isNode(value)) {
-        visit(value, current, visitorKey);
-      }
-    }
-  };
-  visit(node, null, null);
-  return refs;
+	const refs = /* @__PURE__ */ new Set();
+	const visit = (current, parent, key) => {
+		if (!current) return;
+		if (current.type.startsWith("TS")) return;
+		if (t.isIdentifier(current)) {
+			if (shouldCountIdentifierAsReference(parent, key)) refs.add(current.name);
+			return;
+		}
+		for (const visitorKey of t.VISITOR_KEYS[current.type] ?? []) {
+			const value = current[visitorKey];
+			if (Array.isArray(value)) {
+				value.forEach((child) => {
+					if (t.isNode(child)) visit(child, current, visitorKey);
+				});
+				continue;
+			}
+			if (t.isNode(value)) visit(value, current, visitorKey);
+		}
+	};
+	visit(node, null, null);
+	return refs;
 }
 function pruneUnusedTopLevelBindings(statements) {
-  const bindings = /* @__PURE__ */ new Map();
-  const liveStatements = /* @__PURE__ */ new Set();
-  const queue = [];
-  const markLive = (statementIndex) => {
-    if (liveStatements.has(statementIndex)) {
-      return;
-    }
-    liveStatements.add(statementIndex);
-    queue.push(statementIndex);
-  };
-  statements.forEach((statement, statementIndex) => {
-    if (t3.isImportDeclaration(statement)) {
-      for (const specifier of statement.specifiers) {
-        bindings.set(specifier.local.name, { refs: /* @__PURE__ */ new Set(), statementIndex });
-      }
-      return;
-    }
-    if (t3.isVariableDeclaration(statement)) {
-      for (const declaration of statement.declarations) {
-        if (t3.isIdentifier(declaration.id)) {
-          bindings.set(declaration.id.name, {
-            refs: declaration.init ? collectRuntimeReferencedIdentifiers(declaration.init) : /* @__PURE__ */ new Set(),
-            statementIndex
-          });
-        }
-      }
-      return;
-    }
-    if (t3.isExportNamedDeclaration(statement) && t3.isVariableDeclaration(statement.declaration)) {
-      for (const declaration of statement.declaration.declarations) {
-        if (t3.isIdentifier(declaration.id)) {
-          bindings.set(declaration.id.name, {
-            refs: declaration.init ? collectRuntimeReferencedIdentifiers(declaration.init) : /* @__PURE__ */ new Set(),
-            statementIndex
-          });
-        }
-      }
-      markLive(statementIndex);
-      return;
-    }
-    markLive(statementIndex);
-  });
-  while (queue.length > 0) {
-    const statementIndex = queue.pop();
-    const statement = statements[statementIndex];
-    if (!statement) {
-      continue;
-    }
-    const refs = /* @__PURE__ */ new Set();
-    if (t3.isImportDeclaration(statement)) {
-      continue;
-    }
-    if (t3.isVariableDeclaration(statement)) {
-      for (const declaration of statement.declarations) {
-        if (declaration.init) {
-          for (const ref of collectRuntimeReferencedIdentifiers(declaration.init)) {
-            refs.add(ref);
-          }
-        }
-      }
-    } else if (t3.isExportNamedDeclaration(statement) && t3.isVariableDeclaration(statement.declaration)) {
-      for (const declaration of statement.declaration.declarations) {
-        if (declaration.init) {
-          for (const ref of collectRuntimeReferencedIdentifiers(declaration.init)) {
-            refs.add(ref);
-          }
-        }
-      }
-    } else {
-      for (const ref of collectRuntimeReferencedIdentifiers(statement)) {
-        refs.add(ref);
-      }
-    }
-    for (const ref of refs) {
-      const binding = bindings.get(ref);
-      if (binding) {
-        markLive(binding.statementIndex);
-      }
-    }
-  }
-  const prunedStatements = [];
-  statements.forEach((statement, statementIndex) => {
-    if (!liveStatements.has(statementIndex)) {
-      return;
-    }
-    if (t3.isImportDeclaration(statement)) {
-      const specifiers = statement.specifiers.filter(
-        (specifier) => liveStatements.has(bindings.get(specifier.local.name)?.statementIndex ?? -1)
-      );
-      if (specifiers.length > 0) {
-        prunedStatements.push(t3.importDeclaration(specifiers, statement.source));
-      }
-      return;
-    }
-    if (t3.isVariableDeclaration(statement)) {
-      const declarations = statement.declarations.filter(
-        (declaration) => !t3.isIdentifier(declaration.id) || liveStatements.has(bindings.get(declaration.id.name)?.statementIndex ?? -1)
-      );
-      if (declarations.length > 0) {
-        prunedStatements.push(t3.variableDeclaration(statement.kind, declarations));
-      }
-      return;
-    }
-    if (t3.isExportNamedDeclaration(statement) && t3.isVariableDeclaration(statement.declaration)) {
-      const declarations = statement.declaration.declarations.filter(
-        (declaration) => !t3.isIdentifier(declaration.id) || liveStatements.has(bindings.get(declaration.id.name)?.statementIndex ?? -1)
-      );
-      if (declarations.length > 0) {
-        prunedStatements.push(
-          t3.exportNamedDeclaration(t3.variableDeclaration(statement.declaration.kind, declarations))
-        );
-      }
-      return;
-    }
-    prunedStatements.push(statement);
-  });
-  return prunedStatements;
+	const bindings = /* @__PURE__ */ new Map();
+	const liveStatements = /* @__PURE__ */ new Set();
+	const queue = [];
+	const markLive = (statementIndex) => {
+		if (liveStatements.has(statementIndex)) return;
+		liveStatements.add(statementIndex);
+		queue.push(statementIndex);
+	};
+	statements.forEach((statement, statementIndex) => {
+		if (t.isImportDeclaration(statement)) {
+			for (const specifier of statement.specifiers) bindings.set(specifier.local.name, {
+				refs: /* @__PURE__ */ new Set(),
+				statementIndex
+			});
+			return;
+		}
+		if (t.isVariableDeclaration(statement)) {
+			for (const declaration of statement.declarations) if (t.isIdentifier(declaration.id)) bindings.set(declaration.id.name, {
+				refs: declaration.init ? collectRuntimeReferencedIdentifiers(declaration.init) : /* @__PURE__ */ new Set(),
+				statementIndex
+			});
+			return;
+		}
+		if (t.isExportNamedDeclaration(statement) && t.isVariableDeclaration(statement.declaration)) {
+			for (const declaration of statement.declaration.declarations) if (t.isIdentifier(declaration.id)) bindings.set(declaration.id.name, {
+				refs: declaration.init ? collectRuntimeReferencedIdentifiers(declaration.init) : /* @__PURE__ */ new Set(),
+				statementIndex
+			});
+			markLive(statementIndex);
+			return;
+		}
+		markLive(statementIndex);
+	});
+	while (queue.length > 0) {
+		const statement = statements[queue.pop()];
+		if (!statement) continue;
+		const refs = /* @__PURE__ */ new Set();
+		if (t.isImportDeclaration(statement)) continue;
+		if (t.isVariableDeclaration(statement)) {
+			for (const declaration of statement.declarations) if (declaration.init) for (const ref of collectRuntimeReferencedIdentifiers(declaration.init)) refs.add(ref);
+		} else if (t.isExportNamedDeclaration(statement) && t.isVariableDeclaration(statement.declaration)) {
+			for (const declaration of statement.declaration.declarations) if (declaration.init) for (const ref of collectRuntimeReferencedIdentifiers(declaration.init)) refs.add(ref);
+		} else for (const ref of collectRuntimeReferencedIdentifiers(statement)) refs.add(ref);
+		for (const ref of refs) {
+			const binding = bindings.get(ref);
+			if (binding) markLive(binding.statementIndex);
+		}
+	}
+	const prunedStatements = [];
+	statements.forEach((statement, statementIndex) => {
+		if (!liveStatements.has(statementIndex)) return;
+		if (t.isImportDeclaration(statement)) {
+			const specifiers = statement.specifiers.filter((specifier) => liveStatements.has(bindings.get(specifier.local.name)?.statementIndex ?? -1));
+			if (specifiers.length > 0) prunedStatements.push(t.importDeclaration(specifiers, statement.source));
+			return;
+		}
+		if (t.isVariableDeclaration(statement)) {
+			const declarations = statement.declarations.filter((declaration) => !t.isIdentifier(declaration.id) || liveStatements.has(bindings.get(declaration.id.name)?.statementIndex ?? -1));
+			if (declarations.length > 0) prunedStatements.push(t.variableDeclaration(statement.kind, declarations));
+			return;
+		}
+		if (t.isExportNamedDeclaration(statement) && t.isVariableDeclaration(statement.declaration)) {
+			const declarations = statement.declaration.declarations.filter((declaration) => !t.isIdentifier(declaration.id) || liveStatements.has(bindings.get(declaration.id.name)?.statementIndex ?? -1));
+			if (declarations.length > 0) prunedStatements.push(t.exportNamedDeclaration(t.variableDeclaration(statement.declaration.kind, declarations)));
+			return;
+		}
+		prunedStatements.push(statement);
+	});
+	return prunedStatements;
 }
-
-// src/transforms/activities.ts
+//#endregion
+//#region src/transforms/activities.ts
 function normalizeImportPath(importPath, extension) {
-  const normalizedPath = importPath.split(path.sep).join("/");
-  const pathWithExtension = extension === ".mjs" || extension === ".cjs" ? normalizedPath : normalizedPath.replace(/\.[cm]?[jt]sx?$/, "");
-  return pathWithExtension.startsWith(".") ? pathWithExtension : `./${pathWithExtension}`;
+	const normalizedPath = importPath.split(path.sep).join("/");
+	const pathWithExtension = extension === ".mjs" || extension === ".cjs" ? normalizedPath : normalizedPath.replace(/\.[cm]?[jt]sx?$/, "");
+	return pathWithExtension.startsWith(".") ? pathWithExtension : `./${pathWithExtension}`;
 }
 function rebaseModulePath(modulePath, sourceFilePath, outputFilePath) {
-  if (!modulePath.startsWith(".")) {
-    return modulePath;
-  }
-  const resolvedPath = path.resolve(path.dirname(sourceFilePath), modulePath);
-  const relativePath = path.relative(path.dirname(outputFilePath), resolvedPath);
-  return normalizeImportPath(relativePath, path.extname(resolvedPath));
+	if (!modulePath.startsWith(".")) return modulePath;
+	const resolvedPath = path.resolve(path.dirname(sourceFilePath), modulePath);
+	return normalizeImportPath(path.relative(path.dirname(outputFilePath), resolvedPath), path.extname(resolvedPath));
 }
 function collectWorkflowBindingNames(ast) {
-  const workflowNames = /* @__PURE__ */ new Set();
-  for (const statement of ast.program.body) {
-    if (!t3.isVariableDeclaration(statement) && !(t3.isExportNamedDeclaration(statement) && t3.isVariableDeclaration(statement.declaration))) {
-      continue;
-    }
-    const declarationStatement = t3.isVariableDeclaration(statement) ? statement : statement.declaration;
-    for (const declaration of declarationStatement.declarations) {
-      if (t3.isIdentifier(declaration.id) && declaration.init && hasCreateWorkflowCall(declaration.init)) {
-        workflowNames.add(declaration.id.name);
-      }
-    }
-  }
-  return workflowNames;
+	const workflowNames = /* @__PURE__ */ new Set();
+	for (const statement of ast.program.body) {
+		if (!t.isVariableDeclaration(statement) && !(t.isExportNamedDeclaration(statement) && t.isVariableDeclaration(statement.declaration))) continue;
+		const declarationStatement = t.isVariableDeclaration(statement) ? statement : statement.declaration;
+		for (const declaration of declarationStatement.declarations) if (t.isIdentifier(declaration.id) && declaration.init && hasCreateWorkflowCall(declaration.init)) workflowNames.add(declaration.id.name);
+	}
+	return workflowNames;
 }
 function isMastraDeclaration(declaration) {
-  return t3.isIdentifier(declaration.id) && declaration.id.name === "mastra";
+	return t.isIdentifier(declaration.id) && declaration.id.name === "mastra";
 }
 function removeStrippedReferencesFromMastraInitializer(init, strippedNames) {
-  const clonedInit = t3.cloneNode(init, true);
-  if (!t3.isNewExpression(clonedInit) && !t3.isCallExpression(clonedInit)) {
-    return clonedInit;
-  }
-  const config = clonedInit.arguments[0];
-  if (!t3.isObjectExpression(config)) {
-    return clonedInit;
-  }
-  config.properties = config.properties.filter((property) => !nodeReferencesName(property, strippedNames));
-  return clonedInit;
+	const clonedInit = t.cloneNode(init, true);
+	if (!t.isNewExpression(clonedInit) && !t.isCallExpression(clonedInit)) return clonedInit;
+	const config = clonedInit.arguments[0];
+	if (!t.isObjectExpression(config)) return clonedInit;
+	config.properties = config.properties.filter((property) => !nodeReferencesName(property, strippedNames));
+	return clonedInit;
 }
 function createPreservedDeclaration(declaration, strippedNames) {
-  if (!isMastraDeclaration(declaration) || !declaration.init) {
-    return t3.cloneNode(declaration, true);
-  }
-  return t3.variableDeclarator(
-    t3.cloneNode(declaration.id, true),
-    removeStrippedReferencesFromMastraInitializer(declaration.init, strippedNames)
-  );
+	if (!isMastraDeclaration(declaration) || !declaration.init) return t.cloneNode(declaration, true);
+	return t.variableDeclarator(t.cloneNode(declaration.id, true), removeStrippedReferencesFromMastraInitializer(declaration.init, strippedNames));
 }
 function hasLocalMastraBinding(ast) {
-  return ast.program.body.some((statement) => {
-    const declaration = t3.isExportNamedDeclaration(statement) ? statement.declaration : statement;
-    if (!t3.isVariableDeclaration(declaration)) {
-      return false;
-    }
-    return declaration.declarations.some((declarator) => t3.isIdentifier(declarator.id, { name: "mastra" }));
-  });
+	return ast.program.body.some((statement) => {
+		const declaration = t.isExportNamedDeclaration(statement) ? statement.declaration : statement;
+		if (!t.isVariableDeclaration(declaration)) return false;
+		return declaration.declarations.some((declarator) => t.isIdentifier(declarator.id, { name: "mastra" }));
+	});
 }
 function createTemporalActivitiesHelperStatements(mastraImportPath, hasMastraBinding) {
-  const helperSource = hasMastraBinding ? `
+	return parse(mastraImportPath ? `
+        function createStep(args) {
+          return async (params) => {
+            const { mastra } = await import(${JSON.stringify(mastraImportPath)});
+            return args.execute({ ...params, mastra });
+          };
+        }
+      ` : hasMastraBinding ? `
         function createStep(args) {
           return async (params) => {
             return args.execute({ ...params, mastra });
@@ -491,947 +327,711 @@ function createTemporalActivitiesHelperStatements(mastraImportPath, hasMastraBin
             return args.execute(params);
           };
         }
-      `;
-  return parse(helperSource, {
-    sourceType: "module",
-    plugins: parserPlugins
-  }).program.body;
+      `, {
+		sourceType: "module",
+		plugins: parserPlugins
+	}).program.body;
 }
 async function buildTemporalActivitiesModule(entryFile, outputDirectory, outputFileName) {
-  const activityBindings = [];
-  const seenActivityBindingNames = /* @__PURE__ */ new Set();
-  const addActivityBinding = (exportName, call) => {
-    const stepId = getCreateStepId(call);
-    if (!stepId || seenActivityBindingNames.has(exportName)) {
-      return;
-    }
-    seenActivityBindingNames.add(exportName);
-    activityBindings.push({ exportName, stepId });
-  };
-  const bundle = await rollup({
-    input: entryFile,
-    treeshake: "smallest",
-    logLevel: "silent",
-    plugins: [
-      {
-        name: "temporal-workflow-transform",
-        transform(code, id) {
-          const ast = parse(code, {
-            sourceType: "module",
-            plugins: parserPlugins,
-            sourceFilename: id
-          });
-          const statements = [];
-          const seenNames = /* @__PURE__ */ new Set();
-          const strippedNames = /* @__PURE__ */ new Set();
-          const workflowBindingNames = collectWorkflowBindingNames(ast);
-          const stepFactoryBindings = collectCreateStepFactoryBindings(ast.program);
-          const sourceFilePath = id;
-          const hasMastraBinding = hasLocalMastraBinding(ast);
-          let helperInserted = false;
-          const ensureHelperInserted = () => {
-            if (helperInserted) {
-              return;
-            }
-            statements.push(...createTemporalActivitiesHelperStatements(null, hasMastraBinding));
-            helperInserted = true;
-          };
-          for (const statement of ast.program.body) {
-            if (t3.isImportDeclaration(statement)) {
-              if (statement.source.value === "@mastra/core/workflows") {
-                const retainedSpecifiers = statement.specifiers.filter(
-                  (specifier) => !(t3.isImportSpecifier(specifier) && t3.isIdentifier(specifier.imported) && (specifier.imported.name === "createStep" || specifier.imported.name === "createWorkflow"))
-                );
-                if (retainedSpecifiers.length > 0) {
-                  statements.push(t3.importDeclaration(retainedSpecifiers, t3.stringLiteral(statement.source.value)));
-                }
-                continue;
-              }
-              if (isTemporalHelperModule(statement.source.value) || isStrippedExternalModule(statement.source.value)) {
-                for (const name of collectImportedNames(statement)) {
-                  strippedNames.add(name);
-                }
-                continue;
-              }
-              const rewrittenSource = rebaseModulePath(statement.source.value, sourceFilePath, id);
-              if (rewrittenSource === statement.source.value) {
-                statements.push(statement);
-              } else {
-                statements.push(
-                  t3.importDeclaration(
-                    statement.specifiers.map((specifier) => t3.cloneNode(specifier, true)),
-                    t3.stringLiteral(rewrittenSource)
-                  )
-                );
-              }
-              continue;
-            }
-            if (t3.isFunctionDeclaration(statement) || t3.isClassDeclaration(statement) || t3.isTSTypeAliasDeclaration(statement) || t3.isTSInterfaceDeclaration(statement) || t3.isTSEnumDeclaration(statement)) {
-              ensureHelperInserted();
-              statements.push(statement);
-              continue;
-            }
-            if (t3.isExpressionStatement(statement) && nodeReferencesName(statement, strippedNames)) {
-              continue;
-            }
-            ensureHelperInserted();
-            if (t3.isVariableDeclaration(statement)) {
-              const declarations = [];
-              for (const declaration of statement.declarations) {
-                if (isWorkflowHelperDestructure(declaration)) {
-                  continue;
-                }
-                if (declaration.init && nodeReferencesName(declaration.init, strippedNames) && !isMastraDeclaration(declaration)) {
-                  if (t3.isIdentifier(declaration.id)) {
-                    strippedNames.add(declaration.id.name);
-                  }
-                  continue;
-                }
-                if (!t3.isIdentifier(declaration.id) || !declaration.init) {
-                  declarations.push(createPreservedDeclaration(declaration, strippedNames));
-                  continue;
-                }
-                const createStepCall = getCreateStepCallFromExpression(declaration.init, stepFactoryBindings);
-                if (createStepCall) {
-                  const isFactoryCall = t3.isCallExpression(declaration.init) && t3.isIdentifier(declaration.init.callee) && stepFactoryBindings.has(declaration.init.callee.name);
-                  if (isFactoryCall) {
-                    seenNames.add(declaration.id.name);
-                    addActivityBinding(declaration.id.name, createStepCall);
-                    statements.push(
-                      t3.exportNamedDeclaration(t3.variableDeclaration(statement.kind, [t3.cloneNode(declaration, true)]))
-                    );
-                    continue;
-                  }
-                  if (isCreateStepCall(declaration.init)) {
-                    seenNames.add(declaration.id.name);
-                    addActivityBinding(declaration.id.name, createStepCall);
-                    statements.push(createExportedStepStatement(declaration.id.name, createStepCall));
-                    continue;
-                  }
-                }
-                if (hasCreateWorkflowCall(declaration.init)) {
-                  workflowBindingNames.add(declaration.id.name);
-                  strippedNames.add(declaration.id.name);
-                  collectInlineCreateSteps(declaration.init, seenNames, statements, addActivityBinding);
-                  continue;
-                }
-                declarations.push(createPreservedDeclaration(declaration, strippedNames));
-              }
-              if (declarations.length > 0) {
-                statements.push(
-                  t3.variableDeclaration(
-                    statement.kind,
-                    declarations.map((declaration) => t3.cloneNode(declaration, true))
-                  )
-                );
-              }
-              continue;
-            }
-            if (t3.isExportNamedDeclaration(statement) && t3.isVariableDeclaration(statement.declaration)) {
-              const exportedDeclarations = [];
-              const localDeclarations = [];
-              for (const declaration of statement.declaration.declarations) {
-                if (isWorkflowHelperDestructure(declaration)) {
-                  continue;
-                }
-                if (declaration.init && nodeReferencesName(declaration.init, strippedNames) && !isMastraDeclaration(declaration)) {
-                  if (t3.isIdentifier(declaration.id)) {
-                    strippedNames.add(declaration.id.name);
-                  }
-                  continue;
-                }
-                if (!t3.isIdentifier(declaration.id) || !declaration.init) {
-                  exportedDeclarations.push(createPreservedDeclaration(declaration, strippedNames));
-                  continue;
-                }
-                const createStepCall = getCreateStepCallFromExpression(declaration.init, stepFactoryBindings);
-                if (createStepCall) {
-                  const isFactoryCall = t3.isCallExpression(declaration.init) && t3.isIdentifier(declaration.init.callee) && stepFactoryBindings.has(declaration.init.callee.name);
-                  if (isFactoryCall) {
-                    seenNames.add(declaration.id.name);
-                    addActivityBinding(declaration.id.name, createStepCall);
-                    exportedDeclarations.push(createPreservedDeclaration(declaration, strippedNames));
-                    continue;
-                  }
-                  if (isCreateStepCall(declaration.init)) {
-                    seenNames.add(declaration.id.name);
-                    addActivityBinding(declaration.id.name, createStepCall);
-                    statements.push(createExportedStepStatement(declaration.id.name, createStepCall));
-                    continue;
-                  }
-                }
-                if (hasCreateWorkflowCall(declaration.init)) {
-                  workflowBindingNames.add(declaration.id.name);
-                  strippedNames.add(declaration.id.name);
-                  collectInlineCreateSteps(declaration.init, seenNames, statements, addActivityBinding);
-                  continue;
-                }
-                if (declaration.id.name === "mastra") {
-                  localDeclarations.push(createPreservedDeclaration(declaration, strippedNames));
-                  continue;
-                }
-                exportedDeclarations.push(createPreservedDeclaration(declaration, strippedNames));
-              }
-              if (localDeclarations.length > 0) {
-                statements.push(
-                  t3.variableDeclaration(
-                    statement.declaration.kind,
-                    localDeclarations.map((declaration) => t3.cloneNode(declaration, true))
-                  )
-                );
-              }
-              if (exportedDeclarations.length > 0) {
-                statements.push(
-                  t3.exportNamedDeclaration(
-                    t3.variableDeclaration(
-                      statement.declaration.kind,
-                      exportedDeclarations.map((declaration) => t3.cloneNode(declaration, true))
-                    )
-                  )
-                );
-              }
-              continue;
-            }
-            if (t3.isExpressionStatement(statement)) {
-              if (nodeReferencesName(statement, workflowBindingNames) || nodeReferencesName(statement, strippedNames)) {
-                collectInlineCreateSteps(statement, seenNames, statements, addActivityBinding);
-                continue;
-              }
-              collectInlineCreateSteps(statement, seenNames, statements, addActivityBinding);
-              continue;
-            }
-            if (t3.isExportNamedDeclaration(statement)) {
-              if (t3.isFunctionDeclaration(statement.declaration) || t3.isClassDeclaration(statement.declaration) || t3.isTSTypeAliasDeclaration(statement.declaration) || t3.isTSInterfaceDeclaration(statement.declaration) || t3.isTSEnumDeclaration(statement.declaration)) {
-                ensureHelperInserted();
-                statements.push(statement);
-                continue;
-              }
-              if (statement.declaration == null && statement.source == null) {
-                const retainedSpecifiers = statement.specifiers.filter(
-                  (specifier) => t3.isExportSpecifier(specifier) && t3.isIdentifier(specifier.local) && specifier.local.name !== "mastra" && !workflowBindingNames.has(specifier.local.name) && !seenNames.has(specifier.local.name)
-                );
-                if (retainedSpecifiers.length > 0) {
-                  statements.push(t3.exportNamedDeclaration(null, retainedSpecifiers));
-                }
-                continue;
-              }
-              if (statement.declaration == null && statement.source) {
-                const mastraSpecifiers = statement.specifiers.filter(
-                  (specifier) => t3.isExportSpecifier(specifier) && t3.isIdentifier(specifier.exported, { name: "mastra" }) && t3.isIdentifier(specifier.local, { name: "mastra" })
-                );
-                if (mastraSpecifiers.length > 0) {
-                  statements.push(
-                    t3.importDeclaration(
-                      [t3.importSpecifier(t3.identifier("mastra"), t3.identifier("mastra"))],
-                      t3.stringLiteral(rebaseModulePath(statement.source.value, sourceFilePath, id))
-                    )
-                  );
-                }
-                continue;
-              }
-              collectInlineCreateSteps(statement, seenNames, statements, addActivityBinding);
-              continue;
-            }
-            if (t3.isExportDefaultDeclaration(statement)) {
-              if (t3.isIdentifier(statement.declaration) && workflowBindingNames.has(statement.declaration.name)) {
-                continue;
-              }
-              collectInlineCreateSteps(statement, seenNames, statements, addActivityBinding);
-              continue;
-            }
-            statements.push(statement);
-          }
-          ensureHelperInserted();
-          const transformedSource = generate(t3.file(t3.program(pruneUnusedTopLevelBindings(statements), [], "module")), {
-            sourceMaps: true
-          });
-          return {
-            code: transformedSource.code,
-            map: transformedSource.map ? { ...transformedSource.map, file: transformedSource.map.file ?? void 0 } : void 0
-          };
-        }
-      }
-    ]
-  });
-  try {
-    const baseName = basename(outputFileName);
-    const { output } = await bundle.write({
-      dir: outputDirectory,
-      entryFileNames: outputFileName,
-      chunkFileNames: `${baseName}-[hash].mjs`,
-      format: "esm",
-      sourcemap: "inline"
-    });
-    return {
-      outputPath: join(outputDirectory, output.find((chunk) => chunk.type === "chunk" && chunk.isEntry).fileName),
-      activityBindings
-    };
-  } finally {
-    await bundle.close();
-  }
+	const activityBindings = [];
+	const seenActivityBindingNames = /* @__PURE__ */ new Set();
+	const addActivityBinding = (exportName, call) => {
+		const stepId = getCreateStepId(call);
+		if (!stepId || seenActivityBindingNames.has(exportName)) return;
+		seenActivityBindingNames.add(exportName);
+		activityBindings.push({
+			exportName,
+			stepId
+		});
+	};
+	const bundle = await rollup({
+		input: entryFile,
+		treeshake: "smallest",
+		logLevel: "silent",
+		plugins: [{
+			name: "temporal-workflow-transform",
+			transform(code, id) {
+				const ast = parse(code, {
+					sourceType: "module",
+					plugins: parserPlugins,
+					sourceFilename: id
+				});
+				const statements = [];
+				const seenNames = /* @__PURE__ */ new Set();
+				const strippedNames = /* @__PURE__ */ new Set();
+				const workflowBindingNames = collectWorkflowBindingNames(ast);
+				const stepFactoryBindings = collectCreateStepFactoryBindings(ast.program);
+				const sourceFilePath = id;
+				const hasMastraBinding = hasLocalMastraBinding(ast);
+				let helperInserted = false;
+				const ensureHelperInserted = () => {
+					if (helperInserted) return;
+					statements.push(...createTemporalActivitiesHelperStatements(null, hasMastraBinding));
+					helperInserted = true;
+				};
+				for (const statement of ast.program.body) {
+					if (t.isImportDeclaration(statement)) {
+						if (statement.source.value === "@mastra/core/workflows") {
+							const retainedSpecifiers = statement.specifiers.filter((specifier) => !(t.isImportSpecifier(specifier) && t.isIdentifier(specifier.imported) && (specifier.imported.name === "createStep" || specifier.imported.name === "createWorkflow")));
+							if (retainedSpecifiers.length > 0) statements.push(t.importDeclaration(retainedSpecifiers, t.stringLiteral(statement.source.value)));
+							continue;
+						}
+						if (isTemporalHelperModule(statement.source.value) || isStrippedExternalModule(statement.source.value)) {
+							for (const name of collectImportedNames(statement)) strippedNames.add(name);
+							continue;
+						}
+						const rewrittenSource = rebaseModulePath(statement.source.value, sourceFilePath, id);
+						if (rewrittenSource === statement.source.value) statements.push(statement);
+						else statements.push(t.importDeclaration(statement.specifiers.map((specifier) => t.cloneNode(specifier, true)), t.stringLiteral(rewrittenSource)));
+						continue;
+					}
+					if (t.isFunctionDeclaration(statement) || t.isClassDeclaration(statement) || t.isTSTypeAliasDeclaration(statement) || t.isTSInterfaceDeclaration(statement) || t.isTSEnumDeclaration(statement)) {
+						ensureHelperInserted();
+						statements.push(statement);
+						continue;
+					}
+					if (t.isExpressionStatement(statement) && nodeReferencesName(statement, strippedNames)) continue;
+					ensureHelperInserted();
+					if (t.isVariableDeclaration(statement)) {
+						const declarations = [];
+						for (const declaration of statement.declarations) {
+							if (isWorkflowHelperDestructure(declaration)) continue;
+							if (declaration.init && nodeReferencesName(declaration.init, strippedNames) && !isMastraDeclaration(declaration)) {
+								if (t.isIdentifier(declaration.id)) strippedNames.add(declaration.id.name);
+								continue;
+							}
+							if (!t.isIdentifier(declaration.id) || !declaration.init) {
+								declarations.push(createPreservedDeclaration(declaration, strippedNames));
+								continue;
+							}
+							const createStepCall = getCreateStepCallFromExpression(declaration.init, stepFactoryBindings);
+							if (createStepCall) {
+								if (t.isCallExpression(declaration.init) && t.isIdentifier(declaration.init.callee) && stepFactoryBindings.has(declaration.init.callee.name)) {
+									seenNames.add(declaration.id.name);
+									addActivityBinding(declaration.id.name, createStepCall);
+									statements.push(t.exportNamedDeclaration(t.variableDeclaration(statement.kind, [t.cloneNode(declaration, true)])));
+									continue;
+								}
+								if (isCreateStepCall(declaration.init)) {
+									seenNames.add(declaration.id.name);
+									addActivityBinding(declaration.id.name, createStepCall);
+									statements.push(createExportedStepStatement(declaration.id.name, createStepCall));
+									continue;
+								}
+							}
+							if (hasCreateWorkflowCall(declaration.init)) {
+								workflowBindingNames.add(declaration.id.name);
+								strippedNames.add(declaration.id.name);
+								collectInlineCreateSteps(declaration.init, seenNames, statements, addActivityBinding);
+								continue;
+							}
+							declarations.push(createPreservedDeclaration(declaration, strippedNames));
+						}
+						if (declarations.length > 0) statements.push(t.variableDeclaration(statement.kind, declarations.map((declaration) => t.cloneNode(declaration, true))));
+						continue;
+					}
+					if (t.isExportNamedDeclaration(statement) && t.isVariableDeclaration(statement.declaration)) {
+						const exportedDeclarations = [];
+						const localDeclarations = [];
+						for (const declaration of statement.declaration.declarations) {
+							if (isWorkflowHelperDestructure(declaration)) continue;
+							if (declaration.init && nodeReferencesName(declaration.init, strippedNames) && !isMastraDeclaration(declaration)) {
+								if (t.isIdentifier(declaration.id)) strippedNames.add(declaration.id.name);
+								continue;
+							}
+							if (!t.isIdentifier(declaration.id) || !declaration.init) {
+								exportedDeclarations.push(createPreservedDeclaration(declaration, strippedNames));
+								continue;
+							}
+							const createStepCall = getCreateStepCallFromExpression(declaration.init, stepFactoryBindings);
+							if (createStepCall) {
+								if (t.isCallExpression(declaration.init) && t.isIdentifier(declaration.init.callee) && stepFactoryBindings.has(declaration.init.callee.name)) {
+									seenNames.add(declaration.id.name);
+									addActivityBinding(declaration.id.name, createStepCall);
+									exportedDeclarations.push(createPreservedDeclaration(declaration, strippedNames));
+									continue;
+								}
+								if (isCreateStepCall(declaration.init)) {
+									seenNames.add(declaration.id.name);
+									addActivityBinding(declaration.id.name, createStepCall);
+									statements.push(createExportedStepStatement(declaration.id.name, createStepCall));
+									continue;
+								}
+							}
+							if (hasCreateWorkflowCall(declaration.init)) {
+								workflowBindingNames.add(declaration.id.name);
+								strippedNames.add(declaration.id.name);
+								collectInlineCreateSteps(declaration.init, seenNames, statements, addActivityBinding);
+								continue;
+							}
+							if (declaration.id.name === "mastra") {
+								localDeclarations.push(createPreservedDeclaration(declaration, strippedNames));
+								continue;
+							}
+							exportedDeclarations.push(createPreservedDeclaration(declaration, strippedNames));
+						}
+						if (localDeclarations.length > 0) statements.push(t.variableDeclaration(statement.declaration.kind, localDeclarations.map((declaration) => t.cloneNode(declaration, true))));
+						if (exportedDeclarations.length > 0) statements.push(t.exportNamedDeclaration(t.variableDeclaration(statement.declaration.kind, exportedDeclarations.map((declaration) => t.cloneNode(declaration, true)))));
+						continue;
+					}
+					if (t.isExpressionStatement(statement)) {
+						if (nodeReferencesName(statement, workflowBindingNames) || nodeReferencesName(statement, strippedNames)) {
+							collectInlineCreateSteps(statement, seenNames, statements, addActivityBinding);
+							continue;
+						}
+						collectInlineCreateSteps(statement, seenNames, statements, addActivityBinding);
+						continue;
+					}
+					if (t.isExportNamedDeclaration(statement)) {
+						if (t.isFunctionDeclaration(statement.declaration) || t.isClassDeclaration(statement.declaration) || t.isTSTypeAliasDeclaration(statement.declaration) || t.isTSInterfaceDeclaration(statement.declaration) || t.isTSEnumDeclaration(statement.declaration)) {
+							ensureHelperInserted();
+							statements.push(statement);
+							continue;
+						}
+						if (statement.declaration == null && statement.source == null) {
+							const retainedSpecifiers = statement.specifiers.filter((specifier) => t.isExportSpecifier(specifier) && t.isIdentifier(specifier.local) && specifier.local.name !== "mastra" && !workflowBindingNames.has(specifier.local.name) && !seenNames.has(specifier.local.name));
+							if (retainedSpecifiers.length > 0) statements.push(t.exportNamedDeclaration(null, retainedSpecifiers));
+							continue;
+						}
+						if (statement.declaration == null && statement.source) {
+							if (statement.specifiers.filter((specifier) => t.isExportSpecifier(specifier) && t.isIdentifier(specifier.exported, { name: "mastra" }) && t.isIdentifier(specifier.local, { name: "mastra" })).length > 0) statements.push(t.importDeclaration([t.importSpecifier(t.identifier("mastra"), t.identifier("mastra"))], t.stringLiteral(rebaseModulePath(statement.source.value, sourceFilePath, id))));
+							continue;
+						}
+						collectInlineCreateSteps(statement, seenNames, statements, addActivityBinding);
+						continue;
+					}
+					if (t.isExportDefaultDeclaration(statement)) {
+						if (t.isIdentifier(statement.declaration) && workflowBindingNames.has(statement.declaration.name)) continue;
+						collectInlineCreateSteps(statement, seenNames, statements, addActivityBinding);
+						continue;
+					}
+					statements.push(statement);
+				}
+				ensureHelperInserted();
+				const transformedSource = generate(t.file(t.program(pruneUnusedTopLevelBindings(statements), [], "module")), { sourceMaps: true });
+				return {
+					code: transformedSource.code,
+					map: transformedSource.map ? {
+						...transformedSource.map,
+						file: transformedSource.map.file ?? void 0
+					} : void 0
+				};
+			}
+		}]
+	});
+	try {
+		const baseName = basename(outputFileName);
+		const { output } = await bundle.write({
+			dir: outputDirectory,
+			entryFileNames: outputFileName,
+			chunkFileNames: `${baseName}-[hash].mjs`,
+			format: "esm",
+			sourcemap: "inline"
+		});
+		return {
+			outputPath: join(outputDirectory, output.find((chunk) => chunk.type === "chunk" && chunk.isEntry).fileName),
+			activityBindings
+		};
+	} finally {
+		await bundle.close();
+	}
 }
+//#endregion
+//#region src/transforms/workflows.ts
+/**
+* Temporal workflow types must be static so the loader can deterministically map
+* a source workflow to the runtime export name used by the worker.
+*/
 function getWorkflowIdMetadata(workflowConfig, workflowName, filePath) {
-  for (const property of workflowConfig.properties) {
-    if (!t3.isObjectProperty(property) || getObjectPropertyName(property) !== "id") {
-      continue;
-    }
-    if (!t3.isExpression(property.value)) {
-      break;
-    }
-    if (t3.isStringLiteral(property.value)) {
-      return {
-        expression: t3.cloneNode(property.value, true),
-        workflowId: property.value.value
-      };
-    }
-    if (t3.isTemplateLiteral(property.value) && property.value.expressions.length === 0) {
-      return {
-        expression: t3.cloneNode(property.value, true),
-        workflowId: property.value.quasis[0]?.value.cooked ?? ""
-      };
-    }
-    throw new Error(`Workflow id must be a static string for ${workflowName} in ${filePath}`);
-  }
-  throw new Error(`Unable to determine workflow id for ${workflowName} in ${filePath}`);
+	for (const property of workflowConfig.properties) {
+		if (!t.isObjectProperty(property) || getObjectPropertyName(property) !== "id") continue;
+		if (!t.isExpression(property.value)) break;
+		if (t.isStringLiteral(property.value)) return {
+			expression: t.cloneNode(property.value, true),
+			workflowId: property.value.value
+		};
+		if (t.isTemplateLiteral(property.value) && property.value.expressions.length === 0) return {
+			expression: t.cloneNode(property.value, true),
+			workflowId: property.value.quasis[0]?.value.cooked ?? ""
+		};
+		throw new Error(`Workflow id must be a static string for ${workflowName} in ${filePath}`);
+	}
+	throw new Error(`Unable to determine workflow id for ${workflowName} in ${filePath}`);
 }
+/**
+* The helper runtime lives in its own `.mjs` module so it can be linted and unit-tested
+* like normal code. We parse that file directly here instead of using `Function#toString()`,
+* which keeps fixture output stable under Vitest/Vite instrumentation.
+*/
 function createTemporalWorkflowHelperStatements() {
-  const temporalWorkflowRuntimeSource = readFileSync(
-    new URL("./temporal-workflow-runtime.mjs", import.meta.url),
-    "utf8"
-  );
-  const helperProgram = parse(temporalWorkflowRuntimeSource, {
-    sourceType: "module",
-    plugins: parserPlugins
-  }).program.body;
-  return helperProgram.flatMap((statement) => {
-    if (t3.isExportNamedDeclaration(statement) && statement.declaration) {
-      return [statement.declaration];
-    }
-    return [statement];
-  });
+	return parse(readFileSync(new URL("./temporal-workflow-runtime.mjs", import.meta.url), "utf8"), {
+		sourceType: "module",
+		plugins: parserPlugins
+	}).program.body.flatMap((statement) => {
+		if (t.isExportNamedDeclaration(statement) && statement.declaration) return [statement.declaration];
+		return [statement];
+	});
 }
-function getTemporalWorkflowRuntimeOptions(program3) {
-  for (const statement of program3.body) {
-    const declarationStatement = t3.isVariableDeclaration(statement) ? statement : t3.isExportNamedDeclaration(statement) && t3.isVariableDeclaration(statement.declaration) ? statement.declaration : null;
-    if (!declarationStatement) {
-      continue;
-    }
-    for (const declaration of declarationStatement.declarations) {
-      if (!isWorkflowHelperDestructure(declaration) || !t3.isCallExpression(declaration.init)) {
-        continue;
-      }
-      const [temporalParams] = declaration.init.arguments;
-      if (!temporalParams || !t3.isObjectExpression(temporalParams)) {
-        continue;
-      }
-      for (const property of temporalParams.properties) {
-        if (t3.isObjectProperty(property) && getObjectPropertyName(property) === "startToCloseTimeout" && t3.isExpression(property.value)) {
-          return t3.objectExpression([
-            t3.objectProperty(t3.identifier("startToCloseTimeout"), t3.cloneNode(property.value, true))
-          ]);
-        }
-      }
-    }
-  }
+function getTemporalWorkflowRuntimeOptions(program) {
+	for (const statement of program.body) {
+		const declarationStatement = t.isVariableDeclaration(statement) ? statement : t.isExportNamedDeclaration(statement) && t.isVariableDeclaration(statement.declaration) ? statement.declaration : null;
+		if (!declarationStatement) continue;
+		for (const declaration of declarationStatement.declarations) {
+			if (!isWorkflowHelperDestructure(declaration) || !t.isCallExpression(declaration.init)) continue;
+			const [temporalParams] = declaration.init.arguments;
+			if (!temporalParams || !t.isObjectExpression(temporalParams)) continue;
+			for (const property of temporalParams.properties) if (t.isObjectProperty(property) && getObjectPropertyName(property) === "startToCloseTimeout" && t.isExpression(property.value)) return t.objectExpression([t.objectProperty(t.identifier("startToCloseTimeout"), t.cloneNode(property.value, true))]);
+		}
+	}
 }
+/**
+* Walks a chained workflow expression like `createWorkflow(...).then(...).commit()`
+* back to its root `createWorkflow(...)` call while preserving method order.
+*/
 function parseWorkflowChain(node) {
-  const methods = [];
-  let current = node;
-  while (t3.isCallExpression(current) && t3.isMemberExpression(current.callee) && !current.callee.computed) {
-    if (!t3.isIdentifier(current.callee.property)) {
-      return null;
-    }
-    methods.unshift({
-      name: current.callee.property.name,
-      args: current.arguments
-    });
-    current = current.callee.object;
-  }
-  if (!isCreateWorkflowCall(current)) {
-    return null;
-  }
-  return {
-    createWorkflowCall: current,
-    methods
-  };
+	const methods = [];
+	let current = node;
+	while (t.isCallExpression(current) && t.isMemberExpression(current.callee) && !current.callee.computed) {
+		if (!t.isIdentifier(current.callee.property)) return null;
+		methods.unshift({
+			name: current.callee.property.name,
+			args: current.arguments
+		});
+		current = current.callee.object;
+	}
+	if (!isCreateWorkflowCall(current)) return null;
+	return {
+		createWorkflowCall: current,
+		methods
+	};
 }
-function collectStepBindings(program3) {
-  const stepBindings = /* @__PURE__ */ new Map();
-  const stepFactoryBindings = collectCreateStepFactoryBindings(program3);
-  for (const [factoryName, createStepCall] of stepFactoryBindings) {
-    const stepId = getCreateStepId(createStepCall);
-    if (stepId) {
-      stepBindings.set(factoryName, stepId);
-    }
-  }
-  for (const statement of program3.body) {
-    if (!t3.isVariableDeclaration(statement) && !(t3.isExportNamedDeclaration(statement) && t3.isVariableDeclaration(statement.declaration))) {
-      continue;
-    }
-    const declarationStatement = t3.isVariableDeclaration(statement) ? statement : statement.declaration;
-    for (const declaration of declarationStatement.declarations) {
-      if (!t3.isIdentifier(declaration.id) || !declaration.init) {
-        continue;
-      }
-      const createStepCall = getCreateStepCallFromExpression(declaration.init, stepFactoryBindings);
-      const stepId = getCreateStepId(createStepCall);
-      if (stepId) {
-        stepBindings.set(declaration.id.name, stepId);
-      }
-    }
-  }
-  return stepBindings;
+/**
+* Maps local `const someStep = createStep({ id: 'some-step' })` bindings to their
+* runtime ids so later chain rewriting can replace identifier references with ids.
+*/
+function collectStepBindings(program) {
+	const stepBindings = /* @__PURE__ */ new Map();
+	const stepFactoryBindings = collectCreateStepFactoryBindings(program);
+	for (const [factoryName, createStepCall] of stepFactoryBindings) {
+		const stepId = getCreateStepId(createStepCall);
+		if (stepId) stepBindings.set(factoryName, stepId);
+	}
+	for (const statement of program.body) {
+		if (!t.isVariableDeclaration(statement) && !(t.isExportNamedDeclaration(statement) && t.isVariableDeclaration(statement.declaration))) continue;
+		const declarationStatement = t.isVariableDeclaration(statement) ? statement : statement.declaration;
+		for (const declaration of declarationStatement.declarations) {
+			if (!t.isIdentifier(declaration.id) || !declaration.init) continue;
+			const stepId = getCreateStepId(getCreateStepCallFromExpression(declaration.init, stepFactoryBindings));
+			if (stepId) stepBindings.set(declaration.id.name, stepId);
+		}
+	}
+	return stepBindings;
 }
-function collectWorkflowBindings(program3, filePath) {
-  const workflowBindings = /* @__PURE__ */ new Map();
-  for (const statement of program3.body) {
-    if (!t3.isVariableDeclaration(statement) && !(t3.isExportNamedDeclaration(statement) && t3.isVariableDeclaration(statement.declaration))) {
-      continue;
-    }
-    const declarationStatement = t3.isVariableDeclaration(statement) ? statement : statement.declaration;
-    for (const declaration of declarationStatement.declarations) {
-      if (!t3.isIdentifier(declaration.id) || !declaration.init) {
-        continue;
-      }
-      const workflowChain = parseWorkflowChain(declaration.init);
-      const [workflowConfig] = workflowChain?.createWorkflowCall.arguments ?? [];
-      if (!workflowChain || !workflowConfig || !t3.isObjectExpression(workflowConfig)) {
-        continue;
-      }
-      const { workflowId } = getWorkflowIdMetadata(workflowConfig, declaration.id.name, filePath);
-      workflowBindings.set(declaration.id.name, toWorkflowType(workflowId));
-    }
-  }
-  return workflowBindings;
+function collectWorkflowBindings(program, filePath) {
+	const workflowBindings = /* @__PURE__ */ new Map();
+	for (const statement of program.body) {
+		if (!t.isVariableDeclaration(statement) && !(t.isExportNamedDeclaration(statement) && t.isVariableDeclaration(statement.declaration))) continue;
+		const declarationStatement = t.isVariableDeclaration(statement) ? statement : statement.declaration;
+		for (const declaration of declarationStatement.declarations) {
+			if (!t.isIdentifier(declaration.id) || !declaration.init) continue;
+			const workflowChain = parseWorkflowChain(declaration.init);
+			const [workflowConfig] = workflowChain?.createWorkflowCall.arguments ?? [];
+			if (!workflowChain || !workflowConfig || !t.isObjectExpression(workflowConfig)) continue;
+			const { workflowId } = getWorkflowIdMetadata(workflowConfig, declaration.id.name, filePath);
+			workflowBindings.set(declaration.id.name, toWorkflowType(workflowId));
+		}
+	}
+	return workflowBindings;
 }
+/**
+* Accepts the few AST node shapes we allow as "step references" in workflow chains
+* and normalizes them to a single step id string.
+*/
 function getWorkflowStepName(node, stepBindings) {
-  if (!node) {
-    return null;
-  }
-  if (t3.isIdentifier(node)) {
-    return stepBindings.get(node.name) ?? node.name;
-  }
-  if (t3.isStringLiteral(node)) {
-    return node.value;
-  }
-  if (t3.isCallExpression(node) && t3.isIdentifier(node.callee)) {
-    return stepBindings.get(node.callee.name) ?? getCreateStepId(node);
-  }
-  return getCreateStepId(node);
+	if (!node) return null;
+	if (t.isIdentifier(node)) return stepBindings.get(node.name) ?? node.name;
+	if (t.isStringLiteral(node)) return node.value;
+	if (t.isCallExpression(node) && t.isIdentifier(node.callee)) return stepBindings.get(node.callee.name) ?? getCreateStepId(node);
+	return getCreateStepId(node);
 }
+/**
+* Normalizes fluent workflow builder calls into the simpler Temporal runtime shape.
+*
+* Most step references collapse down to step ids so the generated workflow can call
+* activities by id instead of keeping the original `createStep` definitions around.
+*/
 function rewriteChainMethod(method, filePath, workflowName, stepBindings, workflowBindings) {
-  const argNode = (index) => method.args[index];
-  const rewritten = (args, name = method.name) => ({ name, args });
-  switch (method.name) {
-    case "then": {
-      const arg = argNode(0);
-      if (t3.isIdentifier(arg)) {
-        const workflowType = workflowBindings.get(arg.name);
-        if (workflowType) {
-          return rewritten([t3.stringLiteral(workflowType)], "thenWorkflow");
-        }
-      }
-      const name = getWorkflowStepName(arg, stepBindings);
-      if (!name) {
-        throw new Error(
-          `.then() in ${workflowName} (${filePath}) must take a step or workflow identifier (inline createStep calls are not supported)`
-        );
-      }
-      return rewritten([t3.stringLiteral(name)]);
-    }
-    case "sleep": {
-      const arg = argNode(0);
-      if (t3.isNumericLiteral(arg)) {
-        return rewritten([t3.cloneNode(arg, true)]);
-      }
-      const name = getWorkflowStepName(arg, stepBindings);
-      if (!name) {
-        throw new Error(`.sleep() in ${workflowName} (${filePath}) must be a numeric literal or an identifier`);
-      }
-      return rewritten([t3.stringLiteral(name)]);
-    }
-    case "sleepUntil": {
-      const arg = argNode(0);
-      if (t3.isNewExpression(arg) && t3.isIdentifier(arg.callee) && arg.callee.name === "Date") {
-        return rewritten([t3.cloneNode(arg, true)]);
-      }
-      if (t3.isStringLiteral(arg) || t3.isNumericLiteral(arg)) {
-        return rewritten([t3.cloneNode(arg, true)]);
-      }
-      const name = getWorkflowStepName(arg, stepBindings);
-      if (!name) {
-        throw new Error(
-          `.sleepUntil() in ${workflowName} (${filePath}) must be a Date, string/number literal, or an identifier`
-        );
-      }
-      return rewritten([t3.stringLiteral(name)]);
-    }
-    case "parallel": {
-      const arg = argNode(0);
-      if (!t3.isArrayExpression(arg)) {
-        throw new Error(`.parallel() in ${workflowName} (${filePath}) requires an array literal argument`);
-      }
-      const names = arg.elements.map((el) => getWorkflowStepName(el, stepBindings));
-      if (names.some((n) => !n)) {
-        throw new Error(`Unable to determine step names inside .parallel() in ${workflowName} (${filePath})`);
-      }
-      return rewritten([t3.arrayExpression(names.map((n) => t3.stringLiteral(n)))]);
-    }
-    case "branch": {
-      const arg = argNode(0);
-      if (!t3.isArrayExpression(arg)) {
-        throw new Error(
-          `.branch() in ${workflowName} (${filePath}) requires an array literal of [condition, step] pairs`
-        );
-      }
-      const pairs = arg.elements.map((pair) => {
-        if (!t3.isArrayExpression(pair) || pair.elements.length !== 2) {
-          throw new Error(
-            `.branch() pair in ${workflowName} (${filePath}) must be a 2-element array [condition, step]`
-          );
-        }
-        const condName = getWorkflowStepName(pair.elements[0], stepBindings);
-        const stepName = getWorkflowStepName(pair.elements[1], stepBindings);
-        if (!condName || !stepName) {
-          throw new Error(`.branch() condition and step in ${workflowName} (${filePath}) must be identifiers`);
-        }
-        return t3.arrayExpression([t3.stringLiteral(condName), t3.stringLiteral(stepName)]);
-      });
-      return rewritten([t3.arrayExpression(pairs)]);
-    }
-    case "dowhile":
-    case "dountil": {
-      const stepName = getWorkflowStepName(argNode(0), stepBindings);
-      const condName = getWorkflowStepName(argNode(1), stepBindings);
-      if (!stepName || !condName) {
-        throw new Error(`.${method.name}() in ${workflowName} (${filePath}) must take (step, condition) identifiers`);
-      }
-      return rewritten([t3.stringLiteral(stepName), t3.stringLiteral(condName)]);
-    }
-    case "foreach": {
-      const stepName = getWorkflowStepName(argNode(0), stepBindings);
-      if (!stepName) {
-        throw new Error(`.foreach() in ${workflowName} (${filePath}) must take a step identifier`);
-      }
-      const args = [t3.stringLiteral(stepName)];
-      const optsArg = method.args[1];
-      if (optsArg && t3.isExpression(optsArg)) {
-        args.push(t3.cloneNode(optsArg, true));
-      }
-      return rewritten(args);
-    }
-    case "commit":
-      return rewritten([]);
-    default:
-      throw new Error(`Unsupported workflow chain method .${method.name}() in ${workflowName} (${filePath})`);
-  }
+	const argNode = (index) => method.args[index];
+	const rewritten = (args, name = method.name) => ({
+		name,
+		args
+	});
+	switch (method.name) {
+		case "then": {
+			const arg = argNode(0);
+			if (t.isIdentifier(arg)) {
+				const workflowType = workflowBindings.get(arg.name);
+				if (workflowType) return rewritten([t.stringLiteral(workflowType)], "thenWorkflow");
+			}
+			const name = getWorkflowStepName(arg, stepBindings);
+			if (!name) throw new Error(`.then() in ${workflowName} (${filePath}) must take a step or workflow identifier (inline createStep calls are not supported)`);
+			return rewritten([t.stringLiteral(name)]);
+		}
+		case "sleep": {
+			const arg = argNode(0);
+			if (t.isNumericLiteral(arg)) return rewritten([t.cloneNode(arg, true)]);
+			const name = getWorkflowStepName(arg, stepBindings);
+			if (!name) throw new Error(`.sleep() in ${workflowName} (${filePath}) must be a numeric literal or an identifier`);
+			return rewritten([t.stringLiteral(name)]);
+		}
+		case "sleepUntil": {
+			const arg = argNode(0);
+			if (t.isNewExpression(arg) && t.isIdentifier(arg.callee) && arg.callee.name === "Date") return rewritten([t.cloneNode(arg, true)]);
+			if (t.isStringLiteral(arg) || t.isNumericLiteral(arg)) return rewritten([t.cloneNode(arg, true)]);
+			const name = getWorkflowStepName(arg, stepBindings);
+			if (!name) throw new Error(`.sleepUntil() in ${workflowName} (${filePath}) must be a Date, string/number literal, or an identifier`);
+			return rewritten([t.stringLiteral(name)]);
+		}
+		case "parallel": {
+			const arg = argNode(0);
+			if (!t.isArrayExpression(arg)) throw new Error(`.parallel() in ${workflowName} (${filePath}) requires an array literal argument`);
+			const names = arg.elements.map((el) => getWorkflowStepName(el, stepBindings));
+			if (names.some((n) => !n)) throw new Error(`Unable to determine step names inside .parallel() in ${workflowName} (${filePath})`);
+			return rewritten([t.arrayExpression(names.map((n) => t.stringLiteral(n)))]);
+		}
+		case "branch": {
+			const arg = argNode(0);
+			if (!t.isArrayExpression(arg)) throw new Error(`.branch() in ${workflowName} (${filePath}) requires an array literal of [condition, step] pairs`);
+			const pairs = arg.elements.map((pair) => {
+				if (!t.isArrayExpression(pair) || pair.elements.length !== 2) throw new Error(`.branch() pair in ${workflowName} (${filePath}) must be a 2-element array [condition, step]`);
+				const condName = getWorkflowStepName(pair.elements[0], stepBindings);
+				const stepName = getWorkflowStepName(pair.elements[1], stepBindings);
+				if (!condName || !stepName) throw new Error(`.branch() condition and step in ${workflowName} (${filePath}) must be identifiers`);
+				return t.arrayExpression([t.stringLiteral(condName), t.stringLiteral(stepName)]);
+			});
+			return rewritten([t.arrayExpression(pairs)]);
+		}
+		case "dowhile":
+		case "dountil": {
+			const stepName = getWorkflowStepName(argNode(0), stepBindings);
+			const condName = getWorkflowStepName(argNode(1), stepBindings);
+			if (!stepName || !condName) throw new Error(`.${method.name}() in ${workflowName} (${filePath}) must take (step, condition) identifiers`);
+			return rewritten([t.stringLiteral(stepName), t.stringLiteral(condName)]);
+		}
+		case "foreach": {
+			const stepName = getWorkflowStepName(argNode(0), stepBindings);
+			if (!stepName) throw new Error(`.foreach() in ${workflowName} (${filePath}) must take a step identifier`);
+			const args = [t.stringLiteral(stepName)];
+			const optsArg = method.args[1];
+			if (optsArg && t.isExpression(optsArg)) args.push(t.cloneNode(optsArg, true));
+			return rewritten(args);
+		}
+		case "commit": return rewritten([]);
+		default: throw new Error(`Unsupported workflow chain method .${method.name}() in ${workflowName} (${filePath})`);
+	}
 }
 function getExportedName(node) {
-  return t3.isIdentifier(node) ? node.name : node.value;
+	return t.isIdentifier(node) ? node.name : node.value;
 }
+/**
+* Materializes one transformed workflow export.
+*
+* Instead of preserving the original `const workflow = createWorkflow(...)` shape,
+* we emit a deterministic exported function whose name matches Temporal's runtime
+* lookup and whose body delegates into the injected helper runtime.
+*/
 function createTemporalWorkflowStatements(exportName, workflowId, methods, filePath, includeCommit, stepBindings, workflowBindings, runtimeOptions) {
-  const createWorkflowArgs = [t3.cloneNode(workflowId, true)];
-  if (runtimeOptions) {
-    createWorkflowArgs.push(t3.cloneNode(runtimeOptions, true));
-  }
-  let expression = t3.callExpression(t3.identifier("createWorkflow"), createWorkflowArgs);
-  for (const method of methods) {
-    const rewrittenMethod = rewriteChainMethod(method, filePath, exportName, stepBindings, workflowBindings);
-    expression = t3.callExpression(
-      t3.memberExpression(expression, t3.identifier(rewrittenMethod.name)),
-      rewrittenMethod.args
-    );
-  }
-  if (includeCommit && !methods.some((m) => m.name === "commit")) {
-    expression = t3.callExpression(t3.memberExpression(expression, t3.identifier("commit")), []);
-  }
-  const argsParam = t3.identifier("args");
-  const lambda = t3.arrowFunctionExpression(
-    [argsParam],
-    t3.blockStatement([t3.returnStatement(t3.callExpression(expression, [t3.identifier("args")]))])
-  );
-  const declaration = t3.variableDeclaration("const", [t3.variableDeclarator(t3.identifier(exportName), lambda)]);
-  return [t3.exportNamedDeclaration(declaration)];
+	const createWorkflowArgs = [t.cloneNode(workflowId, true)];
+	if (runtimeOptions) createWorkflowArgs.push(t.cloneNode(runtimeOptions, true));
+	let expression = t.callExpression(t.identifier("createWorkflow"), createWorkflowArgs);
+	for (const method of methods) {
+		const rewrittenMethod = rewriteChainMethod(method, filePath, exportName, stepBindings, workflowBindings);
+		expression = t.callExpression(t.memberExpression(expression, t.identifier(rewrittenMethod.name)), rewrittenMethod.args);
+	}
+	if (includeCommit && !methods.some((m) => m.name === "commit")) expression = t.callExpression(t.memberExpression(expression, t.identifier("commit")), []);
+	const argsParam = t.identifier("args");
+	const lambda = t.arrowFunctionExpression([argsParam], t.blockStatement([t.returnStatement(t.callExpression(expression, [t.identifier("args")]))]));
+	const declaration = t.variableDeclaration("const", [t.variableDeclarator(t.identifier(exportName), lambda)]);
+	return [t.exportNamedDeclaration(declaration)];
 }
 function getTemporalWorkflowExportFromDeclaration(declaration, filePath) {
-  if (!t3.isIdentifier(declaration.id) || !declaration.init) {
-    return null;
-  }
-  const workflowChain = parseWorkflowChain(declaration.init);
-  if (!workflowChain) {
-    return null;
-  }
-  const [workflowConfig] = workflowChain.createWorkflowCall.arguments;
-  if (!workflowConfig || !t3.isObjectExpression(workflowConfig)) {
-    throw new Error(`Unable to determine workflow config for ${declaration.id.name} in ${filePath}`);
-  }
-  const { workflowId } = getWorkflowIdMetadata(workflowConfig, declaration.id.name, filePath);
-  return {
-    exportName: toWorkflowType(workflowId),
-    workflowId
-  };
+	if (!t.isIdentifier(declaration.id) || !declaration.init) return null;
+	const workflowChain = parseWorkflowChain(declaration.init);
+	if (!workflowChain) return null;
+	const [workflowConfig] = workflowChain.createWorkflowCall.arguments;
+	if (!workflowConfig || !t.isObjectExpression(workflowConfig)) throw new Error(`Unable to determine workflow config for ${declaration.id.name} in ${filePath}`);
+	const { workflowId } = getWorkflowIdMetadata(workflowConfig, declaration.id.name, filePath);
+	return {
+		exportName: toWorkflowType(workflowId),
+		workflowId
+	};
 }
 function getVariableDeclarationFromStatement(statement) {
-  if (t3.isVariableDeclaration(statement)) {
-    return statement;
-  }
-  if (t3.isExportNamedDeclaration(statement) && t3.isVariableDeclaration(statement.declaration)) {
-    return statement.declaration;
-  }
-  return null;
+	if (t.isVariableDeclaration(statement)) return statement;
+	if (t.isExportNamedDeclaration(statement) && t.isVariableDeclaration(statement.declaration)) return statement.declaration;
+	return null;
 }
 function getCommittedWorkflowName(statement) {
-  if (!t3.isExpressionStatement(statement)) {
-    return null;
-  }
-  const { expression } = statement;
-  if (!t3.isCallExpression(expression) || !t3.isMemberExpression(expression.callee) || expression.callee.computed || !isIdentifierNamed(expression.callee.property, "commit") || !t3.isIdentifier(expression.callee.object)) {
-    return null;
-  }
-  return expression.callee.object.name;
+	if (!t.isExpressionStatement(statement)) return null;
+	const { expression } = statement;
+	if (!t.isCallExpression(expression) || !t.isMemberExpression(expression.callee) || expression.callee.computed || !isIdentifierNamed(expression.callee.property, "commit") || !t.isIdentifier(expression.callee.object)) return null;
+	return expression.callee.object.name;
 }
-function createWorkflowTransformState(program3, filePath) {
-  return {
-    statements: [...createTemporalWorkflowHelperStatements()],
-    workflowNames: /* @__PURE__ */ new Set(),
-    committedWorkflowNames: /* @__PURE__ */ new Set(),
-    inlineExportedWorkflowNames: /* @__PURE__ */ new Set(),
-    strippedNames: /* @__PURE__ */ new Set(),
-    stepBindings: collectStepBindings(program3),
-    workflowBindings: collectWorkflowBindings(program3, filePath),
-    workflowExports: [],
-    runtimeOptions: getTemporalWorkflowRuntimeOptions(program3)
-  };
+function createWorkflowTransformState(program, filePath) {
+	return {
+		statements: [...createTemporalWorkflowHelperStatements()],
+		workflowNames: /* @__PURE__ */ new Set(),
+		committedWorkflowNames: /* @__PURE__ */ new Set(),
+		inlineExportedWorkflowNames: /* @__PURE__ */ new Set(),
+		strippedNames: /* @__PURE__ */ new Set(),
+		stepBindings: collectStepBindings(program),
+		workflowBindings: collectWorkflowBindings(program, filePath),
+		workflowExports: [],
+		runtimeOptions: getTemporalWorkflowRuntimeOptions(program)
+	};
 }
 function collectWorkflowDeclarationMetadata(statement, state) {
-  const declarationStatement = getVariableDeclarationFromStatement(statement);
-  if (!declarationStatement) {
-    return;
-  }
-  for (const declaration of declarationStatement.declarations) {
-    if (!t3.isIdentifier(declaration.id) || !declaration.init) {
-      continue;
-    }
-    if (!parseWorkflowChain(declaration.init)) {
-      continue;
-    }
-    state.workflowNames.add(declaration.id.name);
-    if (t3.isExportNamedDeclaration(statement)) {
-      state.inlineExportedWorkflowNames.add(declaration.id.name);
-    }
-  }
+	const declarationStatement = getVariableDeclarationFromStatement(statement);
+	if (!declarationStatement) return;
+	for (const declaration of declarationStatement.declarations) {
+		if (!t.isIdentifier(declaration.id) || !declaration.init) continue;
+		if (!parseWorkflowChain(declaration.init)) continue;
+		state.workflowNames.add(declaration.id.name);
+		if (t.isExportNamedDeclaration(statement)) state.inlineExportedWorkflowNames.add(declaration.id.name);
+	}
 }
 function collectWorkflowExportMetadata(statement, state) {
-  if (t3.isExportNamedDeclaration(statement) && statement.declaration == null && statement.source == null) {
-    for (const specifier of statement.specifiers) {
-      if (!t3.isExportSpecifier(specifier) || !t3.isIdentifier(specifier.local)) {
-        continue;
-      }
-      if (!state.workflowNames.has(specifier.local.name)) {
-        continue;
-      }
-      if (getExportedName(specifier.exported) === specifier.local.name) {
-        state.inlineExportedWorkflowNames.add(specifier.local.name);
-      }
-    }
-  }
+	if (t.isExportNamedDeclaration(statement) && statement.declaration == null && statement.source == null) for (const specifier of statement.specifiers) {
+		if (!t.isExportSpecifier(specifier) || !t.isIdentifier(specifier.local)) continue;
+		if (!state.workflowNames.has(specifier.local.name)) continue;
+		if (getExportedName(specifier.exported) === specifier.local.name) state.inlineExportedWorkflowNames.add(specifier.local.name);
+	}
 }
-function collectWorkflowTransformMetadata(program3, state) {
-  for (const statement of program3.body) {
-    collectWorkflowDeclarationMetadata(statement, state);
-    const committedWorkflowName = getCommittedWorkflowName(statement);
-    if (committedWorkflowName) {
-      state.committedWorkflowNames.add(committedWorkflowName);
-    }
-    collectWorkflowExportMetadata(statement, state);
-  }
+function collectWorkflowTransformMetadata(program, state) {
+	for (const statement of program.body) {
+		collectWorkflowDeclarationMetadata(statement, state);
+		const committedWorkflowName = getCommittedWorkflowName(statement);
+		if (committedWorkflowName) state.committedWorkflowNames.add(committedWorkflowName);
+		collectWorkflowExportMetadata(statement, state);
+	}
 }
 function rewriteWorkflowImportDeclaration(statement, state) {
-  if (statement.source.value === "@mastra/core/workflows") {
-    const retainedSpecifiers = statement.specifiers.filter(
-      (specifier) => !(t3.isImportSpecifier(specifier) && t3.isIdentifier(specifier.imported) && (specifier.imported.name === "createWorkflow" || specifier.imported.name === "createStep"))
-    );
-    if (retainedSpecifiers.length > 0) {
-      state.statements.push(t3.importDeclaration(retainedSpecifiers, t3.stringLiteral(statement.source.value)));
-    }
-    return;
-  }
-  if (isTemporalHelperModule(statement.source.value) || isStrippedExternalModule(statement.source.value)) {
-    for (const name of collectImportedNames(statement)) {
-      state.strippedNames.add(name);
-    }
-    return;
-  }
-  state.statements.push(statement);
+	if (statement.source.value === "@mastra/core/workflows") {
+		const retainedSpecifiers = statement.specifiers.filter((specifier) => !(t.isImportSpecifier(specifier) && t.isIdentifier(specifier.imported) && (specifier.imported.name === "createWorkflow" || specifier.imported.name === "createStep")));
+		if (retainedSpecifiers.length > 0) state.statements.push(t.importDeclaration(retainedSpecifiers, t.stringLiteral(statement.source.value)));
+		return;
+	}
+	if (isTemporalHelperModule(statement.source.value) || isStrippedExternalModule(statement.source.value)) {
+		for (const name of collectImportedNames(statement)) state.strippedNames.add(name);
+		return;
+	}
+	state.statements.push(statement);
 }
 function getNormalizedWorkflowBindingName(name, state) {
-  if (!state.workflowNames.has(name)) {
-    return null;
-  }
-  return state.workflowBindings.get(name) ?? name;
+	if (!state.workflowNames.has(name)) return null;
+	return state.workflowBindings.get(name) ?? name;
 }
 function rewriteWorkflowNamedExport(statement, state) {
-  if (statement.source != null) {
-    return;
-  }
-  const retainedSpecifiers = statement.specifiers.flatMap((specifier) => {
-    if (!t3.isExportSpecifier(specifier) || !t3.isIdentifier(specifier.local)) {
-      return [];
-    }
-    const normalizedLocalName = getNormalizedWorkflowBindingName(specifier.local.name, state);
-    if (!normalizedLocalName || getExportedName(specifier.exported) === specifier.local.name) {
-      return [];
-    }
-    return [t3.exportSpecifier(t3.identifier(normalizedLocalName), t3.cloneNode(specifier.exported))];
-  });
-  if (retainedSpecifiers.length > 0) {
-    state.statements.push(t3.exportNamedDeclaration(null, retainedSpecifiers));
-  }
+	if (statement.source != null) return;
+	const retainedSpecifiers = statement.specifiers.flatMap((specifier) => {
+		if (!t.isExportSpecifier(specifier) || !t.isIdentifier(specifier.local)) return [];
+		const normalizedLocalName = getNormalizedWorkflowBindingName(specifier.local.name, state);
+		if (!normalizedLocalName || getExportedName(specifier.exported) === specifier.local.name) return [];
+		return [t.exportSpecifier(t.identifier(normalizedLocalName), t.cloneNode(specifier.exported))];
+	});
+	if (retainedSpecifiers.length > 0) state.statements.push(t.exportNamedDeclaration(null, retainedSpecifiers));
 }
 function rewriteWorkflowVariableDeclaration(statement, filePath, state) {
-  const declarationStatement = getVariableDeclarationFromStatement(statement);
-  if (!declarationStatement) {
-    return;
-  }
-  const declarations = [];
-  for (const declaration of declarationStatement.declarations) {
-    if (isWorkflowHelperDestructure(declaration)) {
-      continue;
-    }
-    if (t3.isIdentifier(declaration.id) && state.stepBindings.has(declaration.id.name)) {
-      state.strippedNames.add(declaration.id.name);
-      continue;
-    }
-    if (!t3.isIdentifier(declaration.id) || !declaration.init) {
-      declarations.push(declaration);
-      continue;
-    }
-    const workflowChain = parseWorkflowChain(declaration.init);
-    if (!workflowChain && nodeReferencesName(declaration.init, state.strippedNames)) {
-      state.strippedNames.add(declaration.id.name);
-      continue;
-    }
-    if (!workflowChain) {
-      declarations.push(declaration);
-      continue;
-    }
-    const [workflowConfig] = workflowChain.createWorkflowCall.arguments;
-    if (!workflowConfig || !t3.isObjectExpression(workflowConfig)) {
-      throw new Error(`Unable to determine workflow config for ${declaration.id.name} in ${filePath}`);
-    }
-    const { expression: workflowId } = getWorkflowIdMetadata(workflowConfig, declaration.id.name, filePath);
-    const workflowExport = getTemporalWorkflowExportFromDeclaration(declaration, filePath);
-    if (!workflowExport) {
-      throw new Error(`Unable to determine workflow export for ${declaration.id.name} in ${filePath}`);
-    }
-    const { exportName } = workflowExport;
-    state.workflowExports.push(workflowExport);
-    state.statements.push(
-      ...createTemporalWorkflowStatements(
-        exportName,
-        workflowId,
-        workflowChain.methods,
-        filePath,
-        state.committedWorkflowNames.has(declaration.id.name),
-        state.stepBindings,
-        state.workflowBindings,
-        state.runtimeOptions
-      )
-    );
-  }
-  if (declarations.length > 0) {
-    const cloned = declarations.map((declaration) => t3.cloneNode(declaration, true));
-    state.statements.push(t3.variableDeclaration(declarationStatement.kind, cloned));
-  }
+	const declarationStatement = getVariableDeclarationFromStatement(statement);
+	if (!declarationStatement) return;
+	const declarations = [];
+	for (const declaration of declarationStatement.declarations) {
+		if (isWorkflowHelperDestructure(declaration)) continue;
+		if (t.isIdentifier(declaration.id) && state.stepBindings.has(declaration.id.name)) {
+			state.strippedNames.add(declaration.id.name);
+			continue;
+		}
+		if (!t.isIdentifier(declaration.id) || !declaration.init) {
+			declarations.push(declaration);
+			continue;
+		}
+		const workflowChain = parseWorkflowChain(declaration.init);
+		if (!workflowChain && nodeReferencesName(declaration.init, state.strippedNames)) {
+			state.strippedNames.add(declaration.id.name);
+			continue;
+		}
+		if (!workflowChain) {
+			declarations.push(declaration);
+			continue;
+		}
+		const [workflowConfig] = workflowChain.createWorkflowCall.arguments;
+		if (!workflowConfig || !t.isObjectExpression(workflowConfig)) throw new Error(`Unable to determine workflow config for ${declaration.id.name} in ${filePath}`);
+		const { expression: workflowId } = getWorkflowIdMetadata(workflowConfig, declaration.id.name, filePath);
+		const workflowExport = getTemporalWorkflowExportFromDeclaration(declaration, filePath);
+		if (!workflowExport) throw new Error(`Unable to determine workflow export for ${declaration.id.name} in ${filePath}`);
+		const { exportName } = workflowExport;
+		state.workflowExports.push(workflowExport);
+		state.statements.push(...createTemporalWorkflowStatements(exportName, workflowId, workflowChain.methods, filePath, state.committedWorkflowNames.has(declaration.id.name), state.stepBindings, state.workflowBindings, state.runtimeOptions));
+	}
+	if (declarations.length > 0) {
+		const cloned = declarations.map((declaration) => t.cloneNode(declaration, true));
+		state.statements.push(t.variableDeclaration(declarationStatement.kind, cloned));
+	}
 }
 function rewriteWorkflowStatement(statement, filePath, state) {
-  if (t3.isImportDeclaration(statement)) {
-    rewriteWorkflowImportDeclaration(statement, state);
-    return;
-  }
-  if (getCommittedWorkflowName(statement)) {
-    return;
-  }
-  if (t3.isExportNamedDeclaration(statement)) {
-    if (statement.declaration == null) {
-      rewriteWorkflowNamedExport(statement, state);
-      return;
-    }
-    if (t3.isVariableDeclaration(statement.declaration)) {
-      rewriteWorkflowVariableDeclaration(statement, filePath, state);
-      return;
-    }
-    state.statements.push(statement.declaration);
-    return;
-  }
-  if (t3.isExportDefaultDeclaration(statement) && t3.isIdentifier(statement.declaration)) {
-    const normalizedLocalName = getNormalizedWorkflowBindingName(statement.declaration.name, state);
-    if (normalizedLocalName) {
-      state.statements.push(t3.exportDefaultDeclaration(t3.identifier(normalizedLocalName)));
-    }
-    return;
-  }
-  if (getVariableDeclarationFromStatement(statement)) {
-    rewriteWorkflowVariableDeclaration(statement, filePath, state);
-    return;
-  }
-  state.statements.push(statement);
+	if (t.isImportDeclaration(statement)) {
+		rewriteWorkflowImportDeclaration(statement, state);
+		return;
+	}
+	if (getCommittedWorkflowName(statement)) return;
+	if (t.isExportNamedDeclaration(statement)) {
+		if (statement.declaration == null) {
+			rewriteWorkflowNamedExport(statement, state);
+			return;
+		}
+		if (t.isVariableDeclaration(statement.declaration)) {
+			rewriteWorkflowVariableDeclaration(statement, filePath, state);
+			return;
+		}
+		state.statements.push(statement.declaration);
+		return;
+	}
+	if (t.isExportDefaultDeclaration(statement) && t.isIdentifier(statement.declaration)) {
+		const normalizedLocalName = getNormalizedWorkflowBindingName(statement.declaration.name, state);
+		if (normalizedLocalName) state.statements.push(t.exportDefaultDeclaration(t.identifier(normalizedLocalName)));
+		return;
+	}
+	if (getVariableDeclarationFromStatement(statement)) {
+		rewriteWorkflowVariableDeclaration(statement, filePath, state);
+		return;
+	}
+	state.statements.push(statement);
 }
 async function finalizeWorkflowModule(state) {
-  const transformedSource = generate(t3.file(t3.program(pruneUnusedTopLevelBindings(state.statements), [], "module")), {
-    sourceMaps: true
-  });
-  return {
-    ...transformedSource,
-    workflows: state.workflowExports
-  };
+	return {
+		...generate(t.file(t.program(pruneUnusedTopLevelBindings(state.statements), [], "module")), { sourceMaps: true }),
+		workflows: state.workflowExports
+	};
 }
+/**
+* Transforms a user-authored workflow module into a Temporal-friendly module:
+* - strips Mastra/Temporal setup that cannot run in the workflow sandbox
+* - rewrites fluent workflow chains into deterministic exported functions
+* - returns registry metadata so the entry module can re-export the right names
+*/
 async function buildTemporalWorkflowModule(entryFile, outputDirectory, outputFileName) {
-  const bundle = await rollup({
-    input: entryFile,
-    treeshake: "smallest",
-    logLevel: "silent",
-    plugins: [
-      {
-        name: "temporal-workflow-transform",
-        transform(code, id) {
-          const ast = parseModule(id, code);
-          const state = createWorkflowTransformState(ast.program, id);
-          collectWorkflowTransformMetadata(ast.program, state);
-          for (const statement of ast.program.body) {
-            rewriteWorkflowStatement(statement, id, state);
-          }
-          return finalizeWorkflowModule(state);
-        }
-      }
-    ]
-  });
-  try {
-    const baseName = basename(outputFileName);
-    const { output } = await bundle.write({
-      dir: outputDirectory,
-      entryFileNames: outputFileName,
-      chunkFileNames: `${baseName}-[hash].mjs`,
-      format: "esm",
-      sourcemap: "inline"
-    });
-    return {
-      outputPath: join(outputDirectory, output.find((chunk) => chunk.type === "chunk" && chunk.isEntry).fileName)
-    };
-  } finally {
-    await bundle.close();
-  }
+	const bundle = await rollup({
+		input: entryFile,
+		treeshake: "smallest",
+		logLevel: "silent",
+		plugins: [{
+			name: "temporal-workflow-transform",
+			transform(code, id) {
+				const ast = parseModule(id, code);
+				const state = createWorkflowTransformState(ast.program, id);
+				collectWorkflowTransformMetadata(ast.program, state);
+				for (const statement of ast.program.body) rewriteWorkflowStatement(statement, id, state);
+				return finalizeWorkflowModule(state);
+			}
+		}]
+	});
+	try {
+		const baseName = basename(outputFileName);
+		const { output } = await bundle.write({
+			dir: outputDirectory,
+			entryFileNames: outputFileName,
+			chunkFileNames: `${baseName}-[hash].mjs`,
+			format: "esm",
+			sourcemap: "inline"
+		});
+		return { outputPath: join(outputDirectory, output.find((chunk) => chunk.type === "chunk" && chunk.isEntry).fileName) };
+	} finally {
+		await bundle.close();
+	}
 }
-
-// src/plugin.ts
-var CACHE_PATH = "node_modules/.mastra";
-var WORKFLOW_FILE_NAME = "workflow.mjs";
-var ACTIVITIES_FILE_NAME = "activities.mjs";
-var ACTIVITY_BINDINGS_FILE_NAME = "activity-bindings.json";
+//#endregion
+//#region src/plugin.ts
+const CACHE_PATH = "node_modules/.mastra";
+const WORKFLOW_FILE_NAME = "workflow.mjs";
+const ACTIVITIES_FILE_NAME = "activities.mjs";
+const ACTIVITY_BINDINGS_FILE_NAME = "activity-bindings.json";
 function getGeneratedWorkflowModulePath(outputDir) {
-  return path.join(outputDir, WORKFLOW_FILE_NAME);
+	return path.join(outputDir, WORKFLOW_FILE_NAME);
 }
 function getGeneratedActivitiesModulePath(outputDir) {
-  return path.join(outputDir, ACTIVITIES_FILE_NAME);
+	return path.join(outputDir, ACTIVITIES_FILE_NAME);
 }
 function getActivityBindingsPath(outputDir) {
-  return path.join(outputDir, ACTIVITY_BINDINGS_FILE_NAME);
+	return path.join(outputDir, ACTIVITY_BINDINGS_FILE_NAME);
 }
 var MastraPlugin = class {
-  #prebuildPath = null;
-  #compiledActivitiesModules = /* @__PURE__ */ new Map();
-  name = "Mastra";
-  constructor() {
-  }
-  async #bundleMastra(entryFile, projectRoot, outputDirectory) {
-    const { BuildBundler } = await import('./mastra-deployer-UCBGECM5.js');
-    const normalizedEntryFile = entryFile.startsWith("file:/") ? fileURLToPath(entryFile) : entryFile;
-    const mastraBundler = new BuildBundler();
-    await mastraBundler.prepare(outputDirectory);
-    await mastraBundler.bundle(normalizedEntryFile, outputDirectory, {
-      toolsPaths: [],
-      projectRoot
-    });
-    return path.join(outputDirectory, "output", "index.mjs");
-  }
-  async prebuild({
-    entryFile,
-    projectRoot = process.cwd()
-  }) {
-    const temporalOutputDir = path.resolve(projectRoot, CACHE_PATH);
-    const compiledEntryPath = await this.#bundleMastra(entryFile, projectRoot, temporalOutputDir);
-    await buildTemporalWorkflowModule(compiledEntryPath, temporalOutputDir, WORKFLOW_FILE_NAME);
-    const { activityBindings } = await buildTemporalActivitiesModule(
-      compiledEntryPath,
-      temporalOutputDir,
-      ACTIVITIES_FILE_NAME
-    );
-    await writeFile(getActivityBindingsPath(temporalOutputDir), JSON.stringify(activityBindings, null, 2), "utf8");
-    this.#prebuildPath = temporalOutputDir;
-    return this.getTemporalWorkerOptions(temporalOutputDir);
-  }
-  #loadActivityBindings(activityBindingsPath) {
-    try {
-      const bindings = JSON.parse(readFileSync(activityBindingsPath, "utf8"));
-      return bindings;
-    } catch (error) {
-      throw new Error(`MastraPlugin.prebuild() must be called before use, or ${activityBindingsPath} must exist`, {
-        cause: error
-      });
-    }
-  }
-  #loadCompiledActivitiesModule(activitiesModulePath) {
-    const cachedModule = this.#compiledActivitiesModules.get(activitiesModulePath);
-    if (cachedModule) {
-      return cachedModule;
-    }
-    const modulePromise = import(`${pathToFileURL(activitiesModulePath).href}?t=${Date.now()}`);
-    this.#compiledActivitiesModules.set(activitiesModulePath, modulePromise);
-    return modulePromise;
-  }
-  #generateActivityBindings(activityBindings, compiledActivitiesPath) {
-    const generatedActivities = {};
-    for (const binding of activityBindings) {
-      if (generatedActivities[binding.stepId]) {
-        continue;
-      }
-      generatedActivities[binding.stepId] = async (...args) => {
-        const activityModule = await this.#loadCompiledActivitiesModule(compiledActivitiesPath);
-        const activity = activityModule[binding.exportName];
-        if (typeof activity !== "function") {
-          throw new Error(`Unable to load activity '${binding.exportName}' from ${compiledActivitiesPath}`);
-        }
-        return activity(...args);
-      };
-    }
-    return generatedActivities;
-  }
-  getTemporalWorkerOptions(temporalOutputDir) {
-    const workflowOutputPath = getGeneratedWorkflowModulePath(temporalOutputDir);
-    const activitiesOutputPath = getGeneratedActivitiesModulePath(temporalOutputDir);
-    const activityBindings = this.#loadActivityBindings(getActivityBindingsPath(temporalOutputDir));
-    return {
-      workflowsPath: workflowOutputPath,
-      // workflowBundle: {
-      //   codePath: workflowOutputPath,
-      //   sourceMapPath: `${workflowOutputPath}.map`,
-      // },
-      activities: this.#generateActivityBindings(activityBindings, activitiesOutputPath)
-    };
-  }
-  configureWorker(options) {
-    const augmentedOptions = Object.assign({}, options);
-    if (this.#prebuildPath) {
-      Object.assign(augmentedOptions, this.getTemporalWorkerOptions(this.#prebuildPath));
-    } else {
-      if (!options.workflowsPath || !options.activities) {
-        throw new Error("MastraPlugin.prebuild() must be called before use");
-      }
-    }
-    return augmentedOptions;
-  }
+	#prebuildPath = null;
+	#compiledActivitiesModules = /* @__PURE__ */ new Map();
+	name = "Mastra";
+	constructor() {}
+	async #bundleMastra(entryFile, projectRoot, outputDirectory) {
+		const { BuildBundler } = await import("./mastra-deployer-rZLKb1Em.js");
+		const normalizedEntryFile = entryFile.startsWith("file:/") ? fileURLToPath(entryFile) : entryFile;
+		const mastraBundler = new BuildBundler();
+		await mastraBundler.prepare(outputDirectory);
+		await mastraBundler.bundle(normalizedEntryFile, outputDirectory, {
+			toolsPaths: [],
+			projectRoot
+		});
+		return path.join(outputDirectory, "output", "index.mjs");
+	}
+	async prebuild({ entryFile, projectRoot = process.cwd() }) {
+		const temporalOutputDir = path.resolve(projectRoot, CACHE_PATH);
+		const compiledEntryPath = await this.#bundleMastra(entryFile, projectRoot, temporalOutputDir);
+		await buildTemporalWorkflowModule(compiledEntryPath, temporalOutputDir, WORKFLOW_FILE_NAME);
+		const { activityBindings } = await buildTemporalActivitiesModule(compiledEntryPath, temporalOutputDir, ACTIVITIES_FILE_NAME);
+		await writeFile(getActivityBindingsPath(temporalOutputDir), JSON.stringify(activityBindings, null, 2), "utf8");
+		this.#prebuildPath = temporalOutputDir;
+		return this.getTemporalWorkerOptions(temporalOutputDir);
+	}
+	#loadActivityBindings(activityBindingsPath) {
+		try {
+			return JSON.parse(readFileSync(activityBindingsPath, "utf8"));
+		} catch (error) {
+			throw new Error(`MastraPlugin.prebuild() must be called before use, or ${activityBindingsPath} must exist`, { cause: error });
+		}
+	}
+	#loadCompiledActivitiesModule(activitiesModulePath) {
+		const cachedModule = this.#compiledActivitiesModules.get(activitiesModulePath);
+		if (cachedModule) return cachedModule;
+		const modulePromise = import(`${pathToFileURL(activitiesModulePath).href}?t=${Date.now()}`);
+		this.#compiledActivitiesModules.set(activitiesModulePath, modulePromise);
+		return modulePromise;
+	}
+	#generateActivityBindings(activityBindings, compiledActivitiesPath) {
+		const generatedActivities = {};
+		for (const binding of activityBindings) {
+			if (generatedActivities[binding.stepId]) continue;
+			generatedActivities[binding.stepId] = async (...args) => {
+				const activity = (await this.#loadCompiledActivitiesModule(compiledActivitiesPath))[binding.exportName];
+				if (typeof activity !== "function") throw new Error(`Unable to load activity '${binding.exportName}' from ${compiledActivitiesPath}`);
+				return activity(...args);
+			};
+		}
+		return generatedActivities;
+	}
+	getTemporalWorkerOptions(temporalOutputDir) {
+		const workflowOutputPath = getGeneratedWorkflowModulePath(temporalOutputDir);
+		const activitiesOutputPath = getGeneratedActivitiesModulePath(temporalOutputDir);
+		const activityBindings = this.#loadActivityBindings(getActivityBindingsPath(temporalOutputDir));
+		return {
+			workflowsPath: workflowOutputPath,
+			activities: this.#generateActivityBindings(activityBindings, activitiesOutputPath)
+		};
+	}
+	configureWorker(options) {
+		const augmentedOptions = Object.assign({}, options);
+		if (this.#prebuildPath) Object.assign(augmentedOptions, this.getTemporalWorkerOptions(this.#prebuildPath));
+		else if (!options.workflowsPath || !options.activities) throw new Error("MastraPlugin.prebuild() must be called before use");
+		return augmentedOptions;
+	}
 };
-
+//#endregion
 export { MastraPlugin };
-//# sourceMappingURL=worker.js.map
+
 //# sourceMappingURL=worker.js.map