@mastra/temporal 0.0.0 → 0.1.0-alpha.0

package/dist/worker.js

@@ -0,0 +1,1310 @@
+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",
+  "classProperties",
+  "classPrivateProperties",
+  "classPrivateMethods",
+  "topLevelAwait",
+  "importAttributes",
+  "decorators-legacy"
+];
+function parseModule(filePath, sourceText) {
+  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;
+}
+function isTemporalHelperModule(source) {
+  return typeof source === "string" && /(^|\/)temporal\.(ts|tsx|js|jsx|mts|mjs)$/.test(source);
+}
+var strippedExternalModules = /* @__PURE__ */ new Set(["@temporalio/client", "@temporalio/envconfig"]);
+function isStrippedExternalModule(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;
+}
+function nodeReferencesName(node, names) {
+  let found = false;
+  walk(node, (current) => {
+    if (t3.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")
+  );
+}
+function isCreateWorkflowCall(node) {
+  return t3.isCallExpression(node) && isIdentifierNamed(node.callee, "createWorkflow");
+}
+function isCreateStepCall(node) {
+  return t3.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;
+}
+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);
+    }
+  }
+}
+function hasCreateWorkflowCall(node) {
+  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());
+}
+function createExportedStepStatement(name, initializer) {
+  return t3.exportNamedDeclaration(
+    t3.variableDeclaration("const", [t3.variableDeclarator(t3.identifier(name), t3.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;
+  });
+}
+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;
+}
+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.isTSExpressionWithTypeArguments(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;
+}
+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;
+}
+
+// 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}`;
+}
+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));
+}
+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;
+}
+function isMastraDeclaration(declaration) {
+  return t3.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;
+}
+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)
+  );
+}
+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" }));
+  });
+}
+function createTemporalActivitiesHelperStatements(mastraImportPath, hasMastraBinding) {
+  const helperSource = hasMastraBinding ? `
+        function createStep(args) {
+          return async (params) => {
+            return args.execute({ ...params, mastra });
+          };
+        }
+      ` : `
+        function createStep(args) {
+          return async (params) => {
+            return args.execute(params);
+          };
+        }
+      `;
+  return parse(helperSource, {
+    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 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;
+                }
+                if (isCreateStepCall(declaration.init)) {
+                  seenNames.add(declaration.id.name);
+                  addActivityBinding(declaration.id.name, declaration.init);
+                  statements.push(createExportedStepStatement(declaration.id.name, declaration.init));
+                  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;
+                }
+                if (isCreateStepCall(declaration.init)) {
+                  seenNames.add(declaration.id.name);
+                  addActivityBinding(declaration.id.name, declaration.init);
+                  statements.push(createExportedStepStatement(declaration.id.name, declaration.init));
+                  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 (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 transformedSource;
+        }
+      }
+    ]
+  });
+  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();
+  }
+}
+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}`);
+}
+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];
+  });
+}
+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
+  };
+}
+function collectStepBindings(program3) {
+  const stepBindings = /* @__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 stepId = getCreateStepId(declaration.init);
+      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 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;
+  }
+  return getCreateStepId(node);
+}
+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})`);
+  }
+}
+function getExportedName(node) {
+  return t3.isIdentifier(node) ? node.name : node.value;
+}
+function createTemporalWorkflowStatements(exportName, workflowId, methods, filePath, includeCommit, stepBindings, workflowBindings) {
+  let expression = t3.callExpression(t3.identifier("createWorkflow"), [t3.cloneNode(workflowId, true)]);
+  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)];
+}
+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
+  };
+}
+function getVariableDeclarationFromStatement(statement) {
+  if (t3.isVariableDeclaration(statement)) {
+    return statement;
+  }
+  if (t3.isExportNamedDeclaration(statement) && t3.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;
+}
+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: []
+  };
+}
+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);
+    }
+  }
+}
+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);
+      }
+    }
+  }
+}
+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 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);
+}
+function getNormalizedWorkflowBindingName(name, state) {
+  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));
+  }
+}
+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
+      )
+    );
+  }
+  if (declarations.length > 0) {
+    const cloned = declarations.map((declaration) => t3.cloneNode(declaration, true));
+    state.statements.push(t3.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);
+}
+async function finalizeWorkflowModule(state) {
+  const transformedSource = generate(t3.file(t3.program(pruneUnusedTopLevelBindings(state.statements), [], "module")), {
+    sourceMaps: true
+  });
+  return {
+    ...transformedSource,
+    workflows: state.workflowExports
+  };
+}
+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();
+  }
+}
+
+// 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";
+function getGeneratedWorkflowModulePath(outputDir) {
+  return path.join(outputDir, WORKFLOW_FILE_NAME);
+}
+function getGeneratedActivitiesModulePath(outputDir) {
+  return path.join(outputDir, ACTIVITIES_FILE_NAME);
+}
+function getActivityBindingsPath(outputDir) {
+  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;
+  }
+};
+
+export { MastraPlugin };
+//# sourceMappingURL=worker.js.map
+//# sourceMappingURL=worker.js.map