@mastra/temporal 0.0.0 → 0.1.0-alpha.1

package/dist/index.js

@@ -1,24 +1,6 @@
+import { toWorkflowType } from './chunk-BF6TR7JX.js';
 import { createStep, Workflow, Run } from '@mastra/core/workflows';
-import { readFileSync, statSync } from 'fs';
-import { readFile, writeFile, mkdir } from 'fs/promises';
-import { createRequire } from 'module';
-import path4 from 'path';
-import { fileURLToPath, pathToFileURL } from 'url';
-import { SimplePlugin } from '@temporalio/plugin';
-import { generate } from '@babel/generator';
-import { parse } from '@babel/parser';
-import * as t from '@babel/types';
-import { transform } from 'esbuild';
 
-// src/workflow.ts
-
-// src/utils.ts
-function toWorkflowType(id) {
-  const camelCased = id.replace(/[-_]+([a-zA-Z0-9])/g, (_, char) => char.toUpperCase());
-  return camelCased.endsWith("Workflow") ? camelCased : `${camelCased}Workflow`;
-}
-
-// src/run.ts
 var TemporalRun = class extends Run {
   client;
   taskQueue;
@@ -142,907 +124,7 @@ function init(temporalParams) {
     createStep
   };
 }
-var parserPlugins = [
-  "typescript",
-  "jsx",
-  "classProperties",
-  "classPrivateProperties",
-  "classPrivateMethods",
-  "topLevelAwait",
-  "importAttributes",
-  "decorators-legacy"
-];
-function isIdentifierNamed(node, name) {
-  return t.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 (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 (t.isIdentifier(current) && names.has(current.name)) {
-      found = true;
-      return false;
-    }
-  });
-  return found;
-}
-function isWorkflowHelperDestructure(declaration) {
-  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 t.isCallExpression(node) && isIdentifierNamed(node.callee, "createWorkflow");
-}
-function isCreateStepCall(node) {
-  return t.isCallExpression(node) && isIdentifierNamed(node.callee, "createStep");
-}
-function getObjectPropertyName(property) {
-  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 = 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;
-}
-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 t.exportNamedDeclaration(
-    t.variableDeclaration("const", [t.variableDeclarator(t.identifier(name), t.cloneNode(initializer, true))])
-  );
-}
-function collectInlineCreateSteps(node, seenNames, statements) {
-  walk(node, (current) => {
-    if (!isCreateStepCall(current)) {
-      return;
-    }
-    const stepName = getStepNameFromCall(current);
-    if (!stepName || seenNames.has(stepName)) {
-      return false;
-    }
-    seenNames.add(stepName);
-    statements.push(createExportedStepStatement(stepName, current));
-    return false;
-  });
-}
-async function transpileModule(sourceText, filePath) {
-  const loader = path4.extname(filePath).slice(1) || "js";
-  const { code } = await transform(sourceText, {
-    loader,
-    format: "esm",
-    platform: "node",
-    target: "node22",
-    sourcemap: false,
-    sourcefile: filePath
-  });
-  return code ?? "";
-}
-function getCreateStepId(node) {
-  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 ((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.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 (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 (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 statementIndex = queue.pop();
-    const statement = statements[statementIndex];
-    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
-function collectTemporalActivityBindings(sourceText, filePath) {
-  const ast = parse(sourceText, {
-    sourceType: "module",
-    plugins: parserPlugins,
-    sourceFilename: filePath
-  });
-  const bindings = [];
-  const seenNames = /* @__PURE__ */ new Set();
-  const addBinding = (call) => {
-    const exportName = getStepNameFromCall(call);
-    const stepId = getCreateStepId(call);
-    if (!exportName || !stepId || seenNames.has(exportName)) {
-      return;
-    }
-    seenNames.add(exportName);
-    bindings.push({ exportName, stepId });
-  };
-  const collectInlineBindings = (node) => {
-    walk(node, (current) => {
-      if (!isCreateStepCall(current)) {
-        return;
-      }
-      addBinding(current);
-      return false;
-    });
-  };
-  for (const statement of ast.program.body) {
-    if (t.isVariableDeclaration(statement) || t.isExportNamedDeclaration(statement) && t.isVariableDeclaration(statement.declaration)) {
-      const declarationStatement = t.isVariableDeclaration(statement) ? statement : statement.declaration;
-      for (const declaration of declarationStatement.declarations) {
-        if (!declaration.init) {
-          continue;
-        }
-        if (isCreateStepCall(declaration.init)) {
-          addBinding(declaration.init);
-          continue;
-        }
-        if (hasCreateWorkflowCall(declaration.init)) {
-          collectInlineBindings(declaration.init);
-        }
-      }
-      continue;
-    }
-    if (hasCreateWorkflowCall(statement)) {
-      collectInlineBindings(statement);
-    }
-  }
-  return bindings;
-}
-function createTemporalActivitiesHelperStatements(mastraImportPath = "./index") {
-  const helperSource = `
-    function createStep(args) {
-      return async (params) => {
-        const { mastra } = await import(${JSON.stringify(mastraImportPath)});
-        return args.execute({ ...params, mastra });
-      };
-    }
-  `;
-  return parse(helperSource, {
-    sourceType: "module",
-    plugins: parserPlugins
-  }).program.body;
-}
-async function buildTemporalActivitiesModule(sourceText, filePath, options = {}) {
-  const ast = parse(sourceText, {
-    sourceType: "module",
-    plugins: parserPlugins,
-    sourceFilename: filePath
-  });
-  const statements = [];
-  const seenNames = /* @__PURE__ */ new Set();
-  const strippedNames = /* @__PURE__ */ new Set();
-  let helperInserted = false;
-  const ensureHelperInserted = () => {
-    if (helperInserted) {
-      return;
-    }
-    statements.push(...createTemporalActivitiesHelperStatements(options.mastraImportPath));
-    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;
-      }
-      statements.push(statement);
-      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)) {
-          if (t.isIdentifier(declaration.id)) {
-            strippedNames.add(declaration.id.name);
-          }
-          continue;
-        }
-        if (!t.isIdentifier(declaration.id) || !declaration.init) {
-          declarations.push(declaration);
-          continue;
-        }
-        if (isCreateStepCall(declaration.init)) {
-          seenNames.add(declaration.id.name);
-          statements.push(createExportedStepStatement(declaration.id.name, declaration.init));
-          continue;
-        }
-        if (hasCreateWorkflowCall(declaration.init)) {
-          collectInlineCreateSteps(declaration.init, seenNames, statements);
-          continue;
-        }
-        declarations.push(declaration);
-      }
-      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 declarations = [];
-      for (const declaration of statement.declaration.declarations) {
-        if (isWorkflowHelperDestructure(declaration)) {
-          continue;
-        }
-        if (declaration.init && nodeReferencesName(declaration.init, strippedNames)) {
-          if (t.isIdentifier(declaration.id)) {
-            strippedNames.add(declaration.id.name);
-          }
-          continue;
-        }
-        if (!t.isIdentifier(declaration.id) || !declaration.init) {
-          declarations.push(declaration);
-          continue;
-        }
-        if (isCreateStepCall(declaration.init)) {
-          seenNames.add(declaration.id.name);
-          statements.push(createExportedStepStatement(declaration.id.name, declaration.init));
-          continue;
-        }
-        if (hasCreateWorkflowCall(declaration.init)) {
-          collectInlineCreateSteps(declaration.init, seenNames, statements);
-          continue;
-        }
-        declarations.push(declaration);
-      }
-      if (declarations.length > 0) {
-        statements.push(
-          t.exportNamedDeclaration(
-            t.variableDeclaration(
-              statement.declaration.kind,
-              declarations.map((declaration) => t.cloneNode(declaration, true))
-            )
-          )
-        );
-      }
-      continue;
-    }
-    if (t.isExpressionStatement(statement) || t.isExportNamedDeclaration(statement) || t.isExportDefaultDeclaration(statement)) {
-      collectInlineCreateSteps(statement, seenNames, statements);
-      continue;
-    }
-    statements.push(statement);
-  }
-  ensureHelperInserted();
-  const transformedSource = generate(t.file(t.program(pruneUnusedTopLevelBindings(statements), [], "module")), {
-    sourceMaps: false
-  }).code;
-  return transpileModule(transformedSource, filePath);
-}
-function getWorkflowImportBindings(program3) {
-  const bindings = /* @__PURE__ */ new Map();
-  for (const statement of program3.body) {
-    if (!t.isImportDeclaration(statement)) {
-      continue;
-    }
-    for (const specifier of statement.specifiers) {
-      if (t.isImportSpecifier(specifier)) {
-        bindings.set(specifier.local.name, {
-          exportName: specifier.local.name,
-          importedName: t.isIdentifier(specifier.imported) ? specifier.imported.name : specifier.imported.value,
-          source: statement.source.value
-        });
-        continue;
-      }
-      if (t.isImportDefaultSpecifier(specifier)) {
-        bindings.set(specifier.local.name, {
-          exportName: specifier.local.name,
-          importedName: "default",
-          source: statement.source.value
-        });
-      }
-    }
-  }
-  return bindings;
-}
-function getWorkflowEntryBindings(program3) {
-  const workflowBindings = /* @__PURE__ */ new Set();
-  walk(program3, (node) => {
-    if (!t.isNewExpression(node) || !isIdentifierNamed(node.callee, "Mastra")) {
-      return;
-    }
-    const [config] = node.arguments;
-    if (!t.isObjectExpression(config)) {
-      return;
-    }
-    const workflowsProperty = config.properties.find(
-      (property) => t.isObjectProperty(property) && getObjectPropertyName(property) === "workflows"
-    );
-    if (!workflowsProperty || !t.isObjectExpression(workflowsProperty.value)) {
-      return;
-    }
-    for (const property of workflowsProperty.value.properties) {
-      if (!t.isObjectProperty(property)) {
-        continue;
-      }
-      if (property.shorthand && t.isIdentifier(property.key)) {
-        workflowBindings.add(property.key.name);
-        continue;
-      }
-      if (t.isIdentifier(property.value)) {
-        workflowBindings.add(property.value.name);
-      }
-    }
-  });
-  return workflowBindings;
-}
-readFileSync(new URL("./temporal-workflow-runtime.mjs", import.meta.url), "utf8");
-async function buildWorkflowEntryModuleFromRegistry(sourceText, filePath, registry) {
-  const ast = parse(sourceText, {
-    sourceType: "module",
-    plugins: parserPlugins,
-    sourceFilename: filePath
-  });
-  const workflowBindings = getWorkflowEntryBindings(ast.program);
-  const importBindings = getWorkflowImportBindings(ast.program);
-  const exportStatements = [];
-  const seenExports = /* @__PURE__ */ new Set();
-  for (const workflowBinding of workflowBindings) {
-    const importedBinding = importBindings.get(workflowBinding);
-    if (!importedBinding) {
-      throw new Error(`Unable to find an import for workflow '${workflowBinding}' in ${filePath}`);
-    }
-    const workflowPath = resolveWorkflowPathSync(importedBinding.source, filePath);
-    const exportNames = registry.get(workflowPath);
-    if (!exportNames || exportNames.length === 0) {
-      throw new Error(`Unable to find registered workflow exports for ${workflowPath}`);
-    }
-    for (const exportName of exportNames) {
-      const exportKey = `${importedBinding.source}:${exportName}`;
-      if (seenExports.has(exportKey)) {
-        continue;
-      }
-      seenExports.add(exportKey);
-      exportStatements.push(
-        t.exportNamedDeclaration(
-          null,
-          [t.exportSpecifier(t.identifier(exportName), t.identifier(exportName))],
-          t.stringLiteral(importedBinding.source)
-        )
-      );
-    }
-  }
-  return generate(t.file(t.program(exportStatements, [], "module")), {
-    sourceMaps: false
-  }).code;
-}
-function getWorkflowImportSpecifiers(sourceText, filePath) {
-  const ast = parse(sourceText, {
-    sourceType: "module",
-    plugins: parserPlugins,
-    sourceFilename: filePath
-  });
-  const workflowBindings = getWorkflowEntryBindings(ast.program);
-  const importBindings = getWorkflowImportBindings(ast.program);
-  const workflowSpecifiers = [];
-  for (const workflowBinding of workflowBindings) {
-    const importedBinding = importBindings.get(workflowBinding);
-    if (!importedBinding) {
-      throw new Error(`Unable to find an import for workflow '${workflowBinding}' in ${filePath}`);
-    }
-    workflowSpecifiers.push(importedBinding.source);
-  }
-  return [...new Set(workflowSpecifiers)];
-}
-function getWorkflowPathCandidates(specifier, importerPath) {
-  const basePath = path4.resolve(path4.dirname(importerPath), specifier);
-  return [
-    basePath,
-    `${basePath}.ts`,
-    `${basePath}.tsx`,
-    `${basePath}.js`,
-    `${basePath}.jsx`,
-    `${basePath}.mts`,
-    `${basePath}.mjs`,
-    path4.join(basePath, "index.ts"),
-    path4.join(basePath, "index.tsx"),
-    path4.join(basePath, "index.js"),
-    path4.join(basePath, "index.jsx"),
-    path4.join(basePath, "index.mts"),
-    path4.join(basePath, "index.mjs")
-  ];
-}
-function resolveWorkflowPathSync(specifier, importerPath) {
-  for (const candidate of getWorkflowPathCandidates(specifier, importerPath)) {
-    try {
-      if (statSync(candidate).isFile()) {
-        return candidate;
-      }
-    } catch {
-    }
-  }
-  throw new Error(`Unable to resolve workflow import '${specifier}' from ${importerPath}`);
-}
-function resolveWorkflowEntriesSync(sourceText, filePath) {
-  return getWorkflowImportSpecifiers(sourceText, filePath).map(
-    (specifier) => resolveWorkflowPathSync(specifier, filePath)
-  );
-}
-function getModuleSource(module) {
-  const source = module.originalSource?.() ?? module._source;
-  if (!source) {
-    return null;
-  }
-  return source.source().toString();
-}
-async function writeDebugEntryModule(entryFile, code, debugOutputDir) {
-  if (!debugOutputDir) {
-    return;
-  }
-  const baseDir = path4.dirname(entryFile);
-  const relativePath = path4.relative(baseDir, entryFile);
-  const safeRelativePath = relativePath.startsWith("..") ? path4.basename(entryFile) : relativePath;
-  const outputPath = path4.join(debugOutputDir, "modules", safeRelativePath);
-  await mkdir(path4.dirname(outputPath), { recursive: true });
-  await writeFile(outputPath, code, "utf-8");
-}
-var WorkflowExportRegistry = class {
-  exportsByFile = /* @__PURE__ */ new Map();
-  register(filePath, exportNames) {
-    if (exportNames.length === 0) {
-      return;
-    }
-    this.exportsByFile.set(filePath, [...new Set(exportNames)]);
-  }
-  get(filePath) {
-    return this.exportsByFile.get(filePath);
-  }
-  asMap() {
-    return this.exportsByFile;
-  }
-};
-var MastraWorkflowEntryPlugin = class {
-  constructor(options) {
-    this.options = options;
-  }
-  options;
-  apply(compiler) {
-    compiler.hooks.compilation.tap("MastraWorkflowEntryPlugin", (compilation) => {
-      compilation.hooks.finishModules.tapPromise("MastraWorkflowEntryPlugin", async (modules) => {
-        const entryModule = [...modules].find(
-          (module) => "resource" in module && module.resource === this.options.entryFile
-        );
-        if (!entryModule) {
-          return;
-        }
-        const source = getModuleSource(entryModule);
-        if (!source) {
-          return;
-        }
-        const code = await buildWorkflowEntryModuleFromRegistry(
-          source,
-          this.options.entryFile,
-          this.options.registry.asMap()
-        );
-        entryModule._source = new compiler.webpack.sources.RawSource(code);
-        entryModule._ast = null;
-        entryModule._sourceSizes?.clear?.();
-        await writeDebugEntryModule(this.options.entryFile, code, this.options.debugOutputDir);
-      });
-    });
-  }
-};
-
-// src/plugin.ts
-function getDebugOutputDir() {
-  return path4.resolve(process.cwd(), ".mastra/temporal");
-}
-function getGeneratedActivitiesModulePath(workflowPath) {
-  const extension = path4.extname(workflowPath);
-  const baseName = path4.basename(workflowPath, extension);
-  return path4.join(path4.dirname(workflowPath), `.${baseName}.temporal.activities.mjs`);
-}
-function getMastraImportPath(workflowPath, entryFile) {
-  const relativePath = path4.relative(path4.dirname(workflowPath), entryFile);
-  return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
-}
-var WriteWebpackBundleDebugPlugin = class {
-  constructor(outputDir) {
-    this.outputDir = outputDir;
-  }
-  outputDir;
-  apply(compiler) {
-    compiler.hooks.assetEmitted.tapPromise(
-      "MastraTemporalWriteWebpackBundleDebugPlugin",
-      async (filename, { content }) => {
-        const bundleDir = path4.join(this.outputDir, "bundle");
-        const targetPath = path4.join(bundleDir, filename);
-        await mkdir(path4.dirname(targetPath), { recursive: true });
-        await writeFile(targetPath, content);
-      }
-    );
-  }
-};
-var MastraPlugin = class extends SimplePlugin {
-  src;
-  debugOutputDir;
-  compiledActivities = /* @__PURE__ */ new Map();
-  constructor({ src, debug = false }) {
-    super({
-      name: "Mastra"
-    });
-    this.src = src.startsWith("file://") ? fileURLToPath(src) : src;
-    this.debugOutputDir = debug ? getDebugOutputDir() : null;
-  }
-  loadWorkflowActivitiesModule(workflowPath) {
-    const cachedModule = this.compiledActivities.get(workflowPath);
-    if (cachedModule) {
-      return cachedModule;
-    }
-    const modulePromise = (async () => {
-      const sourceText = await readFile(workflowPath, "utf8");
-      const generatedModulePath = getGeneratedActivitiesModulePath(workflowPath);
-      const transformedModule = await buildTemporalActivitiesModule(sourceText, workflowPath, {
-        mastraImportPath: getMastraImportPath(workflowPath, this.src)
-      });
-      await writeFile(generatedModulePath, transformedModule);
-      const importedModule = await import(pathToFileURL(generatedModulePath).href);
-      return importedModule;
-    })();
-    this.compiledActivities.set(workflowPath, modulePromise);
-    return modulePromise;
-  }
-  configureWorker(options) {
-    const entrySource = readFileSync(this.src, "utf8");
-    const workflowPaths = resolveWorkflowEntriesSync(entrySource, this.src);
-    const generatedActivities = Object.assign({}, options.activities);
-    for (const workflowPath of workflowPaths) {
-      const workflowSource = readFileSync(workflowPath, "utf8");
-      const activityBindings = collectTemporalActivityBindings(workflowSource, workflowPath);
-      for (const binding of activityBindings) {
-        if (generatedActivities[binding.stepId]) {
-          continue;
-        }
-        generatedActivities[binding.stepId] = async (...args) => {
-          const activityModule = await this.loadWorkflowActivitiesModule(workflowPath);
-          const activity = activityModule[binding.exportName];
-          if (typeof activity !== "function") {
-            throw new Error(`Unable to load activity '${binding.exportName}' from ${workflowPath}`);
-          }
-          return activity(...args);
-        };
-      }
-    }
-    return {
-      ...options,
-      workflowsPath: this.src,
-      activities: generatedActivities
-    };
-  }
-  configureBundler(options) {
-    const require2 = createRequire(import.meta.url);
-    const loader = require2.resolve("@mastra/temporal/webpack-loader");
-    const existingWebpackConfigHook = options.webpackConfigHook;
-    const registry = new WorkflowExportRegistry();
-    const webpackConfigHook = (config) => {
-      const nextConfig = existingWebpackConfigHook ? existingWebpackConfigHook(config) : config;
-      const rules = nextConfig.module?.rules ?? [];
-      const plugins = [
-        ...nextConfig.plugins ?? [],
-        new MastraWorkflowEntryPlugin({
-          entryFile: this.src,
-          registry,
-          debugOutputDir: this.debugOutputDir
-        })
-      ];
-      if (this.debugOutputDir) {
-        plugins.push(new WriteWebpackBundleDebugPlugin(this.debugOutputDir));
-      }
-      return {
-        ...nextConfig,
-        module: {
-          ...nextConfig.module,
-          rules: [
-            ...rules,
-            {
-              test: /\.(ts|tsx|js|jsx)$/,
-              exclude: /node_modules/,
-              use: {
-                loader,
-                options: {
-                  entryFile: this.src,
-                  debugOutputDir: this.debugOutputDir,
-                  registry
-                }
-              }
-            }
-          ]
-        },
-        plugins
-      };
-    };
-    return {
-      ...options,
-      webpackConfigHook
-    };
-  }
-};
 
-export { MastraPlugin, init };
+export { init };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map