@mastra/temporal 0.0.0 → 0.1.0-alpha.1

package/dist/index.cjs

@@ -1,50 +1,8 @@
 'use strict';
 
+var chunkDYBSPLCJ_cjs = require('./chunk-DYBSPLCJ.cjs');
 var workflows = require('@mastra/core/workflows');
-var fs = require('fs');
-var promises = require('fs/promises');
-var module$1 = require('module');
-var path4 = require('path');
-var url = require('url');
-var plugin = require('@temporalio/plugin');
-var generator = require('@babel/generator');
-var parser = require('@babel/parser');
-var t = require('@babel/types');
-var esbuild = require('esbuild');
 
-var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
-var path4__default = /*#__PURE__*/_interopDefault(path4);
-var t__namespace = /*#__PURE__*/_interopNamespace(t);
-
-// 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 workflows.Run {
   client;
   taskQueue;
@@ -58,7 +16,7 @@ var TemporalRun = class extends workflows.Run {
     const initialState = await this._validateInitialState(args.initialState);
     await this._validateRequestContext(args.requestContext);
     try {
-      const handle = await this.client.workflow.start(toWorkflowType(this.workflowId), {
+      const handle = await this.client.workflow.start(chunkDYBSPLCJ_cjs.toWorkflowType(this.workflowId), {
         taskQueue: this.taskQueue,
         workflowId: this.runId,
         args: [
@@ -96,7 +54,7 @@ var TemporalRun = class extends workflows.Run {
     const input = await this._validateInput(args.inputData);
     const initialState = await this._validateInitialState(args.initialState);
     await this._validateRequestContext(args.requestContext);
-    await this.client.workflow.start(toWorkflowType(this.workflowId), {
+    await this.client.workflow.start(chunkDYBSPLCJ_cjs.toWorkflowType(this.workflowId), {
       taskQueue: this.taskQueue,
       workflowId: this.runId,
       args: [
@@ -168,908 +126,7 @@ function init(temporalParams) {
     createStep: workflows.createStep
   };
 }
-var parserPlugins = [
-  "typescript",
-  "jsx",
-  "classProperties",
-  "classPrivateProperties",
-  "classPrivateMethods",
-  "topLevelAwait",
-  "importAttributes",
-  "decorators-legacy"
-];
-function isIdentifierNamed(node, name) {
-  return t__namespace.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__namespace.isImportDefaultSpecifier(specifier) || t__namespace.isImportNamespaceSpecifier(specifier) || t__namespace.isImportSpecifier(specifier)) {
-      if (t__namespace.isIdentifier(specifier.local)) {
-        names.add(specifier.local.name);
-      }
-    }
-  }
-  return names;
-}
-function nodeReferencesName(node, names) {
-  let found = false;
-  walk(node, (current) => {
-    if (t__namespace.isIdentifier(current) && names.has(current.name)) {
-      found = true;
-      return false;
-    }
-  });
-  return found;
-}
-function isWorkflowHelperDestructure(declaration) {
-  if (!t__namespace.isObjectPattern(declaration.id)) {
-    return false;
-  }
-  return declaration.id.properties.some(
-    (property) => t__namespace.isObjectProperty(property) && !property.computed && t__namespace.isIdentifier(property.value) && (property.value.name === "createStep" || property.value.name === "createWorkflow")
-  );
-}
-function isCreateWorkflowCall(node) {
-  return t__namespace.isCallExpression(node) && isIdentifierNamed(node.callee, "createWorkflow");
-}
-function isCreateStepCall(node) {
-  return t__namespace.isCallExpression(node) && isIdentifierNamed(node.callee, "createStep");
-}
-function getObjectPropertyName(property) {
-  if (property.computed) {
-    return null;
-  }
-  if (t__namespace.isIdentifier(property.key)) {
-    return property.key.name;
-  }
-  if (t__namespace.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__namespace.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__namespace.exportNamedDeclaration(
-    t__namespace.variableDeclaration("const", [t__namespace.variableDeclarator(t__namespace.identifier(name), t__namespace.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__default.default.extname(filePath).slice(1) || "js";
-  const { code } = await esbuild.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__namespace.isObjectExpression(config)) {
-    return null;
-  }
-  for (const property of config.properties) {
-    if (!t__namespace.isObjectProperty(property) && !t__namespace.isObjectMethod(property)) {
-      continue;
-    }
-    if (getObjectPropertyName(property) !== "id") {
-      continue;
-    }
-    const value = t__namespace.isObjectMethod(property) ? null : property.value;
-    return t__namespace.isStringLiteral(value) ? value.value : null;
-  }
-  return null;
-}
-function shouldCountIdentifierAsReference(parent, key) {
-  if (!parent) {
-    return true;
-  }
-  if ((t__namespace.isObjectProperty(parent) || t__namespace.isObjectMethod(parent)) && key === "key" && !parent.computed) {
-    return false;
-  }
-  if (t__namespace.isMemberExpression(parent) && key === "property" && !parent.computed) {
-    return false;
-  }
-  if (t__namespace.isVariableDeclarator(parent) && key === "id") {
-    return false;
-  }
-  if ((t__namespace.isFunctionDeclaration(parent) || t__namespace.isFunctionExpression(parent) || t__namespace.isArrowFunctionExpression(parent)) && key === "params") {
-    return false;
-  }
-  if ((t__namespace.isFunctionDeclaration(parent) || t__namespace.isFunctionExpression(parent) || t__namespace.isClassDeclaration(parent)) && key === "id") {
-    return false;
-  }
-  if ((t__namespace.isImportSpecifier(parent) || t__namespace.isImportDefaultSpecifier(parent) || t__namespace.isImportNamespaceSpecifier(parent)) && (key === "local" || key === "imported")) {
-    return false;
-  }
-  if (t__namespace.isExportSpecifier(parent) && key === "exported") {
-    return false;
-  }
-  if (t__namespace.isLabeledStatement(parent) && key === "label") {
-    return false;
-  }
-  if (t__namespace.isCatchClause(parent) && key === "param") {
-    return false;
-  }
-  if (t__namespace.isRestElement(parent) && key === "argument") {
-    return false;
-  }
-  if (t__namespace.isAssignmentPattern(parent) && key === "left") {
-    return false;
-  }
-  if (t__namespace.isTSPropertySignature(parent) || t__namespace.isTSMethodSignature(parent) || t__namespace.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__namespace.isIdentifier(current)) {
-      if (shouldCountIdentifierAsReference(parent, key)) {
-        refs.add(current.name);
-      }
-      return;
-    }
-    for (const visitorKey of t__namespace.VISITOR_KEYS[current.type] ?? []) {
-      const value = current[visitorKey];
-      if (Array.isArray(value)) {
-        value.forEach((child) => {
-          if (t__namespace.isNode(child)) {
-            visit(child, current, visitorKey);
-          }
-        });
-        continue;
-      }
-      if (t__namespace.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__namespace.isImportDeclaration(statement)) {
-      for (const specifier of statement.specifiers) {
-        bindings.set(specifier.local.name, { refs: /* @__PURE__ */ new Set(), statementIndex });
-      }
-      return;
-    }
-    if (t__namespace.isVariableDeclaration(statement)) {
-      for (const declaration of statement.declarations) {
-        if (t__namespace.isIdentifier(declaration.id)) {
-          bindings.set(declaration.id.name, {
-            refs: declaration.init ? collectRuntimeReferencedIdentifiers(declaration.init) : /* @__PURE__ */ new Set(),
-            statementIndex
-          });
-        }
-      }
-      return;
-    }
-    if (t__namespace.isExportNamedDeclaration(statement) && t__namespace.isVariableDeclaration(statement.declaration)) {
-      for (const declaration of statement.declaration.declarations) {
-        if (t__namespace.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__namespace.isImportDeclaration(statement)) {
-      continue;
-    }
-    if (t__namespace.isVariableDeclaration(statement)) {
-      for (const declaration of statement.declarations) {
-        if (declaration.init) {
-          for (const ref of collectRuntimeReferencedIdentifiers(declaration.init)) {
-            refs.add(ref);
-          }
-        }
-      }
-    } else if (t__namespace.isExportNamedDeclaration(statement) && t__namespace.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__namespace.isImportDeclaration(statement)) {
-      const specifiers = statement.specifiers.filter(
-        (specifier) => liveStatements.has(bindings.get(specifier.local.name)?.statementIndex ?? -1)
-      );
-      if (specifiers.length > 0) {
-        prunedStatements.push(t__namespace.importDeclaration(specifiers, statement.source));
-      }
-      return;
-    }
-    if (t__namespace.isVariableDeclaration(statement)) {
-      const declarations = statement.declarations.filter(
-        (declaration) => !t__namespace.isIdentifier(declaration.id) || liveStatements.has(bindings.get(declaration.id.name)?.statementIndex ?? -1)
-      );
-      if (declarations.length > 0) {
-        prunedStatements.push(t__namespace.variableDeclaration(statement.kind, declarations));
-      }
-      return;
-    }
-    if (t__namespace.isExportNamedDeclaration(statement) && t__namespace.isVariableDeclaration(statement.declaration)) {
-      const declarations = statement.declaration.declarations.filter(
-        (declaration) => !t__namespace.isIdentifier(declaration.id) || liveStatements.has(bindings.get(declaration.id.name)?.statementIndex ?? -1)
-      );
-      if (declarations.length > 0) {
-        prunedStatements.push(
-          t__namespace.exportNamedDeclaration(t__namespace.variableDeclaration(statement.declaration.kind, declarations))
-        );
-      }
-      return;
-    }
-    prunedStatements.push(statement);
-  });
-  return prunedStatements;
-}
-
-// src/transforms/activities.ts
-function collectTemporalActivityBindings(sourceText, filePath) {
-  const ast = parser.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__namespace.isVariableDeclaration(statement) || t__namespace.isExportNamedDeclaration(statement) && t__namespace.isVariableDeclaration(statement.declaration)) {
-      const declarationStatement = t__namespace.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 parser.parse(helperSource, {
-    sourceType: "module",
-    plugins: parserPlugins
-  }).program.body;
-}
-async function buildTemporalActivitiesModule(sourceText, filePath, options = {}) {
-  const ast = parser.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__namespace.isImportDeclaration(statement)) {
-      if (statement.source.value === "@mastra/core/workflows") {
-        const retainedSpecifiers = statement.specifiers.filter(
-          (specifier) => !(t__namespace.isImportSpecifier(specifier) && t__namespace.isIdentifier(specifier.imported) && (specifier.imported.name === "createStep" || specifier.imported.name === "createWorkflow"))
-        );
-        if (retainedSpecifiers.length > 0) {
-          statements.push(t__namespace.importDeclaration(retainedSpecifiers, t__namespace.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__namespace.isFunctionDeclaration(statement) || t__namespace.isClassDeclaration(statement) || t__namespace.isTSTypeAliasDeclaration(statement) || t__namespace.isTSInterfaceDeclaration(statement) || t__namespace.isTSEnumDeclaration(statement)) {
-      ensureHelperInserted();
-      statements.push(statement);
-      continue;
-    }
-    if (t__namespace.isExpressionStatement(statement) && nodeReferencesName(statement, strippedNames)) {
-      continue;
-    }
-    ensureHelperInserted();
-    if (t__namespace.isVariableDeclaration(statement)) {
-      const declarations = [];
-      for (const declaration of statement.declarations) {
-        if (isWorkflowHelperDestructure(declaration)) {
-          continue;
-        }
-        if (declaration.init && nodeReferencesName(declaration.init, strippedNames)) {
-          if (t__namespace.isIdentifier(declaration.id)) {
-            strippedNames.add(declaration.id.name);
-          }
-          continue;
-        }
-        if (!t__namespace.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__namespace.variableDeclaration(
-            statement.kind,
-            declarations.map((declaration) => t__namespace.cloneNode(declaration, true))
-          )
-        );
-      }
-      continue;
-    }
-    if (t__namespace.isExportNamedDeclaration(statement) && t__namespace.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__namespace.isIdentifier(declaration.id)) {
-            strippedNames.add(declaration.id.name);
-          }
-          continue;
-        }
-        if (!t__namespace.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__namespace.exportNamedDeclaration(
-            t__namespace.variableDeclaration(
-              statement.declaration.kind,
-              declarations.map((declaration) => t__namespace.cloneNode(declaration, true))
-            )
-          )
-        );
-      }
-      continue;
-    }
-    if (t__namespace.isExpressionStatement(statement) || t__namespace.isExportNamedDeclaration(statement) || t__namespace.isExportDefaultDeclaration(statement)) {
-      collectInlineCreateSteps(statement, seenNames, statements);
-      continue;
-    }
-    statements.push(statement);
-  }
-  ensureHelperInserted();
-  const transformedSource = generator.generate(t__namespace.file(t__namespace.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__namespace.isImportDeclaration(statement)) {
-      continue;
-    }
-    for (const specifier of statement.specifiers) {
-      if (t__namespace.isImportSpecifier(specifier)) {
-        bindings.set(specifier.local.name, {
-          exportName: specifier.local.name,
-          importedName: t__namespace.isIdentifier(specifier.imported) ? specifier.imported.name : specifier.imported.value,
-          source: statement.source.value
-        });
-        continue;
-      }
-      if (t__namespace.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__namespace.isNewExpression(node) || !isIdentifierNamed(node.callee, "Mastra")) {
-      return;
-    }
-    const [config] = node.arguments;
-    if (!t__namespace.isObjectExpression(config)) {
-      return;
-    }
-    const workflowsProperty = config.properties.find(
-      (property) => t__namespace.isObjectProperty(property) && getObjectPropertyName(property) === "workflows"
-    );
-    if (!workflowsProperty || !t__namespace.isObjectExpression(workflowsProperty.value)) {
-      return;
-    }
-    for (const property of workflowsProperty.value.properties) {
-      if (!t__namespace.isObjectProperty(property)) {
-        continue;
-      }
-      if (property.shorthand && t__namespace.isIdentifier(property.key)) {
-        workflowBindings.add(property.key.name);
-        continue;
-      }
-      if (t__namespace.isIdentifier(property.value)) {
-        workflowBindings.add(property.value.name);
-      }
-    }
-  });
-  return workflowBindings;
-}
-fs.readFileSync(new URL("./temporal-workflow-runtime.mjs", (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))), "utf8");
-async function buildWorkflowEntryModuleFromRegistry(sourceText, filePath, registry) {
-  const ast = parser.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__namespace.exportNamedDeclaration(
-          null,
-          [t__namespace.exportSpecifier(t__namespace.identifier(exportName), t__namespace.identifier(exportName))],
-          t__namespace.stringLiteral(importedBinding.source)
-        )
-      );
-    }
-  }
-  return generator.generate(t__namespace.file(t__namespace.program(exportStatements, [], "module")), {
-    sourceMaps: false
-  }).code;
-}
-function getWorkflowImportSpecifiers(sourceText, filePath) {
-  const ast = parser.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__default.default.resolve(path4__default.default.dirname(importerPath), specifier);
-  return [
-    basePath,
-    `${basePath}.ts`,
-    `${basePath}.tsx`,
-    `${basePath}.js`,
-    `${basePath}.jsx`,
-    `${basePath}.mts`,
-    `${basePath}.mjs`,
-    path4__default.default.join(basePath, "index.ts"),
-    path4__default.default.join(basePath, "index.tsx"),
-    path4__default.default.join(basePath, "index.js"),
-    path4__default.default.join(basePath, "index.jsx"),
-    path4__default.default.join(basePath, "index.mts"),
-    path4__default.default.join(basePath, "index.mjs")
-  ];
-}
-function resolveWorkflowPathSync(specifier, importerPath) {
-  for (const candidate of getWorkflowPathCandidates(specifier, importerPath)) {
-    try {
-      if (fs.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__default.default.dirname(entryFile);
-  const relativePath = path4__default.default.relative(baseDir, entryFile);
-  const safeRelativePath = relativePath.startsWith("..") ? path4__default.default.basename(entryFile) : relativePath;
-  const outputPath = path4__default.default.join(debugOutputDir, "modules", safeRelativePath);
-  await promises.mkdir(path4__default.default.dirname(outputPath), { recursive: true });
-  await promises.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__default.default.resolve(process.cwd(), ".mastra/temporal");
-}
-function getGeneratedActivitiesModulePath(workflowPath) {
-  const extension = path4__default.default.extname(workflowPath);
-  const baseName = path4__default.default.basename(workflowPath, extension);
-  return path4__default.default.join(path4__default.default.dirname(workflowPath), `.${baseName}.temporal.activities.mjs`);
-}
-function getMastraImportPath(workflowPath, entryFile) {
-  const relativePath = path4__default.default.relative(path4__default.default.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__default.default.join(this.outputDir, "bundle");
-        const targetPath = path4__default.default.join(bundleDir, filename);
-        await promises.mkdir(path4__default.default.dirname(targetPath), { recursive: true });
-        await promises.writeFile(targetPath, content);
-      }
-    );
-  }
-};
-var MastraPlugin = class extends plugin.SimplePlugin {
-  src;
-  debugOutputDir;
-  compiledActivities = /* @__PURE__ */ new Map();
-  constructor({ src, debug = false }) {
-    super({
-      name: "Mastra"
-    });
-    this.src = src.startsWith("file://") ? url.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 promises.readFile(workflowPath, "utf8");
-      const generatedModulePath = getGeneratedActivitiesModulePath(workflowPath);
-      const transformedModule = await buildTemporalActivitiesModule(sourceText, workflowPath, {
-        mastraImportPath: getMastraImportPath(workflowPath, this.src)
-      });
-      await promises.writeFile(generatedModulePath, transformedModule);
-      const importedModule = await import(url.pathToFileURL(generatedModulePath).href);
-      return importedModule;
-    })();
-    this.compiledActivities.set(workflowPath, modulePromise);
-    return modulePromise;
-  }
-  configureWorker(options) {
-    const entrySource = fs.readFileSync(this.src, "utf8");
-    const workflowPaths = resolveWorkflowEntriesSync(entrySource, this.src);
-    const generatedActivities = Object.assign({}, options.activities);
-    for (const workflowPath of workflowPaths) {
-      const workflowSource = fs.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 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
-    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
-    };
-  }
-};
 
-exports.MastraPlugin = MastraPlugin;
 exports.init = init;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map