@mastra/temporal 0.0.0 → 0.1.0-alpha.0

package/dist/webpack-loader.cjs

@@ -1,856 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/webpack-loader.ts
-var webpack_loader_exports = {};
-__export(webpack_loader_exports, {
-  default: () => mastraTemporalWorkflowLoader
-});
-module.exports = __toCommonJS(webpack_loader_exports);
-var import_promises = require("fs/promises");
-var import_node_path3 = __toESM(require("path"), 1);
-
-// src/transforms/workflows.ts
-var import_node_fs = require("fs");
-var import_node_path2 = __toESM(require("path"), 1);
-var import_generator = require("@babel/generator");
-var import_parser = require("@babel/parser");
-var t2 = __toESM(require("@babel/types"), 1);
-
-// 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/transforms/shared.ts
-var import_node_path = __toESM(require("path"), 1);
-var t = __toESM(require("@babel/types"), 1);
-var import_esbuild = require("esbuild");
-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);
-    }
-  }
-}
-async function transpileModule(sourceText, filePath) {
-  const loader = import_node_path.default.extname(filePath).slice(1) || "js";
-  const { code } = await (0, import_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.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/workflows.ts
-var import_meta = {};
-function getWorkflowIdMetadata(workflowConfig, workflowName, filePath) {
-  for (const property of workflowConfig.properties) {
-    if (!t2.isObjectProperty(property) || getObjectPropertyName(property) !== "id") {
-      continue;
-    }
-    if (!t2.isExpression(property.value)) {
-      break;
-    }
-    if (t2.isStringLiteral(property.value)) {
-      return {
-        expression: t2.cloneNode(property.value, true),
-        workflowId: property.value.value
-      };
-    }
-    if (t2.isTemplateLiteral(property.value) && property.value.expressions.length === 0) {
-      return {
-        expression: t2.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}`);
-}
-var temporalWorkflowRuntimeSource = (0, import_node_fs.readFileSync)(new URL("./temporal-workflow-runtime.mjs", import_meta.url), "utf8");
-function createTemporalWorkflowHelperStatements() {
-  const helperProgram = (0, import_parser.parse)(temporalWorkflowRuntimeSource, {
-    sourceType: "module",
-    plugins: parserPlugins
-  }).program.body;
-  return helperProgram.flatMap((statement) => {
-    if (t2.isExportNamedDeclaration(statement) && statement.declaration) {
-      return [statement.declaration];
-    }
-    return [statement];
-  });
-}
-function parseWorkflowChain(node) {
-  const methods = [];
-  let current = node;
-  while (t2.isCallExpression(current) && t2.isMemberExpression(current.callee) && !current.callee.computed) {
-    if (!t2.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(program2) {
-  const stepBindings = /* @__PURE__ */ new Map();
-  for (const statement of program2.body) {
-    if (!t2.isVariableDeclaration(statement) && !(t2.isExportNamedDeclaration(statement) && t2.isVariableDeclaration(statement.declaration))) {
-      continue;
-    }
-    const declarationStatement = t2.isVariableDeclaration(statement) ? statement : statement.declaration;
-    for (const declaration of declarationStatement.declarations) {
-      if (!t2.isIdentifier(declaration.id) || !declaration.init) {
-        continue;
-      }
-      const stepId = getCreateStepId(declaration.init);
-      if (stepId) {
-        stepBindings.set(declaration.id.name, stepId);
-      }
-    }
-  }
-  return stepBindings;
-}
-function getWorkflowStepName(node, stepBindings) {
-  if (!node) {
-    return null;
-  }
-  if (t2.isIdentifier(node)) {
-    return stepBindings.get(node.name) ?? node.name;
-  }
-  if (t2.isStringLiteral(node)) {
-    return node.value;
-  }
-  return getCreateStepId(node);
-}
-function rewriteChainMethod(method, filePath, workflowName, stepBindings) {
-  const argNode = (index) => method.args[index];
-  switch (method.name) {
-    case "then": {
-      const name = getWorkflowStepName(argNode(0), stepBindings);
-      if (!name) {
-        throw new Error(
-          `.then() in ${workflowName} (${filePath}) must take a step identifier (inline createStep calls are not supported)`
-        );
-      }
-      return [t2.stringLiteral(name)];
-    }
-    case "sleep": {
-      const arg = argNode(0);
-      if (t2.isNumericLiteral(arg)) {
-        return [t2.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 [t2.stringLiteral(name)];
-    }
-    case "sleepUntil": {
-      const arg = argNode(0);
-      if (t2.isNewExpression(arg) && t2.isIdentifier(arg.callee) && arg.callee.name === "Date") {
-        return [t2.cloneNode(arg, true)];
-      }
-      if (t2.isStringLiteral(arg) || t2.isNumericLiteral(arg)) {
-        return [t2.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 [t2.stringLiteral(name)];
-    }
-    case "parallel": {
-      const arg = argNode(0);
-      if (!t2.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 [t2.arrayExpression(names.map((n) => t2.stringLiteral(n)))];
-    }
-    case "branch": {
-      const arg = argNode(0);
-      if (!t2.isArrayExpression(arg)) {
-        throw new Error(
-          `.branch() in ${workflowName} (${filePath}) requires an array literal of [condition, step] pairs`
-        );
-      }
-      const pairs = arg.elements.map((pair) => {
-        if (!t2.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 t2.arrayExpression([t2.stringLiteral(condName), t2.stringLiteral(stepName)]);
-      });
-      return [t2.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 [t2.stringLiteral(stepName), t2.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 = [t2.stringLiteral(stepName)];
-      const optsArg = method.args[1];
-      if (optsArg && t2.isExpression(optsArg)) {
-        args.push(t2.cloneNode(optsArg, true));
-      }
-      return args;
-    }
-    case "commit":
-      return [];
-    default:
-      throw new Error(`Unsupported workflow chain method .${method.name}() in ${workflowName} (${filePath})`);
-  }
-}
-function getExportedName(node) {
-  return t2.isIdentifier(node) ? node.name : node.value;
-}
-function createTemporalWorkflowStatements(exportName, workflowId, methods, filePath, includeCommit, exportInline, stepBindings) {
-  let expression = t2.callExpression(t2.identifier("createWorkflow"), [t2.cloneNode(workflowId, true)]);
-  for (const method of methods) {
-    const newArgs = rewriteChainMethod(method, filePath, exportName, stepBindings);
-    expression = t2.callExpression(t2.memberExpression(expression, t2.identifier(method.name)), newArgs);
-  }
-  if (includeCommit && !methods.some((m) => m.name === "commit")) {
-    expression = t2.callExpression(t2.memberExpression(expression, t2.identifier("commit")), []);
-  }
-  const argsParam = t2.identifier("args");
-  const lambda = t2.arrowFunctionExpression(
-    [argsParam],
-    t2.blockStatement([t2.returnStatement(t2.callExpression(expression, [t2.identifier("args")]))])
-  );
-  const declaration = t2.variableDeclaration("const", [t2.variableDeclarator(t2.identifier(exportName), lambda)]);
-  return [exportInline ? t2.exportNamedDeclaration(declaration) : declaration];
-}
-function parseWorkflowModuleAst(sourceText, filePath) {
-  return (0, import_parser.parse)(sourceText, {
-    sourceType: "module",
-    plugins: parserPlugins,
-    sourceFilename: filePath
-  });
-}
-function getVariableDeclarationFromStatement(statement) {
-  if (t2.isVariableDeclaration(statement)) {
-    return statement;
-  }
-  if (t2.isExportNamedDeclaration(statement) && t2.isVariableDeclaration(statement.declaration)) {
-    return statement.declaration;
-  }
-  return null;
-}
-function getCommittedWorkflowName(statement) {
-  if (!t2.isExpressionStatement(statement)) {
-    return null;
-  }
-  const { expression } = statement;
-  if (!t2.isCallExpression(expression) || !t2.isMemberExpression(expression.callee) || expression.callee.computed || !isIdentifierNamed(expression.callee.property, "commit") || !t2.isIdentifier(expression.callee.object)) {
-    return null;
-  }
-  return expression.callee.object.name;
-}
-function createWorkflowTransformState(program2) {
-  return {
-    statements: [...createTemporalWorkflowHelperStatements()],
-    workflowNames: /* @__PURE__ */ new Set(),
-    generatedWorkflowNames: /* @__PURE__ */ new Set(),
-    committedWorkflowNames: /* @__PURE__ */ new Set(),
-    committedGeneratedWorkflowNames: /* @__PURE__ */ new Set(),
-    inlineExportedWorkflowNames: /* @__PURE__ */ new Set(),
-    strippedNames: /* @__PURE__ */ new Set(),
-    stepBindings: collectStepBindings(program2),
-    workflowExports: []
-  };
-}
-function collectWorkflowDeclarationMetadata(statement, state) {
-  const declarationStatement = getVariableDeclarationFromStatement(statement);
-  if (!declarationStatement) {
-    return;
-  }
-  for (const declaration of declarationStatement.declarations) {
-    if (!t2.isIdentifier(declaration.id) || !declaration.init) {
-      continue;
-    }
-    if (!parseWorkflowChain(declaration.init)) {
-      continue;
-    }
-    state.workflowNames.add(declaration.id.name);
-    if (t2.isExportNamedDeclaration(statement)) {
-      state.inlineExportedWorkflowNames.add(declaration.id.name);
-    }
-  }
-}
-function collectWorkflowExportMetadata(statement, state) {
-  if (t2.isExportNamedDeclaration(statement) && statement.declaration == null && statement.source == null) {
-    for (const specifier of statement.specifiers) {
-      if (!t2.isExportSpecifier(specifier) || !t2.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(program2, state) {
-  for (const statement of program2.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) => !(t2.isImportSpecifier(specifier) && t2.isIdentifier(specifier.imported) && (specifier.imported.name === "createWorkflow" || specifier.imported.name === "createStep"))
-    );
-    if (retainedSpecifiers.length > 0) {
-      state.statements.push(t2.importDeclaration(retainedSpecifiers, t2.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 rewriteWorkflowNamedExport(statement, state) {
-  if (statement.source != null) {
-    state.statements.push(statement);
-    return;
-  }
-  const retainedSpecifiers = statement.specifiers.filter((specifier) => {
-    if (!t2.isExportSpecifier(specifier) || !t2.isIdentifier(specifier.local)) {
-      return true;
-    }
-    if (!state.workflowNames.has(specifier.local.name)) {
-      return true;
-    }
-    return getExportedName(specifier.exported) !== specifier.local.name;
-  });
-  if (retainedSpecifiers.length > 0) {
-    state.statements.push(t2.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 (t2.isIdentifier(declaration.id) && state.stepBindings.has(declaration.id.name)) {
-      state.strippedNames.add(declaration.id.name);
-      continue;
-    }
-    if (!t2.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 || !t2.isObjectExpression(workflowConfig)) {
-      throw new Error(`Unable to determine workflow config for ${declaration.id.name} in ${filePath}`);
-    }
-    const { expression: workflowId, workflowId: workflowIdValue } = getWorkflowIdMetadata(
-      workflowConfig,
-      declaration.id.name,
-      filePath
-    );
-    const exportName = toWorkflowType(workflowIdValue);
-    state.generatedWorkflowNames.add(exportName);
-    if (state.committedWorkflowNames.has(declaration.id.name)) {
-      state.committedGeneratedWorkflowNames.add(exportName);
-    }
-    state.workflowExports.push({
-      exportName,
-      workflowId: workflowIdValue
-    });
-    state.statements.push(
-      ...createTemporalWorkflowStatements(
-        exportName,
-        workflowId,
-        workflowChain.methods,
-        filePath,
-        state.committedWorkflowNames.has(declaration.id.name),
-        t2.isExportNamedDeclaration(statement) || state.inlineExportedWorkflowNames.has(declaration.id.name),
-        state.stepBindings
-      )
-    );
-  }
-  if (declarations.length > 0) {
-    const cloned = declarations.map((declaration) => t2.cloneNode(declaration, true));
-    state.statements.push(
-      t2.isVariableDeclaration(statement) ? t2.variableDeclaration(statement.kind, cloned) : t2.exportNamedDeclaration(t2.variableDeclaration(declarationStatement.kind, cloned))
-    );
-  }
-}
-function rewriteWorkflowStatement(statement, filePath, state) {
-  if (t2.isImportDeclaration(statement)) {
-    rewriteWorkflowImportDeclaration(statement, state);
-    return;
-  }
-  if (getCommittedWorkflowName(statement)) {
-    return;
-  }
-  if (t2.isExportNamedDeclaration(statement) && statement.declaration == null) {
-    rewriteWorkflowNamedExport(statement, state);
-    return;
-  }
-  if (t2.isExportDefaultDeclaration(statement) && t2.isIdentifier(statement.declaration)) {
-    if (state.workflowNames.has(statement.declaration.name)) {
-      state.statements.push(statement);
-    }
-    return;
-  }
-  if (getVariableDeclarationFromStatement(statement)) {
-    rewriteWorkflowVariableDeclaration(statement, filePath, state);
-    return;
-  }
-  state.statements.push(statement);
-}
-function appendMissingWorkflowCommits(state) {
-  for (const workflowName of state.generatedWorkflowNames) {
-    if (state.committedGeneratedWorkflowNames.has(workflowName)) {
-      continue;
-    }
-    state.statements.push(
-      t2.expressionStatement(
-        t2.callExpression(t2.memberExpression(t2.identifier(workflowName), t2.identifier("commit")), [])
-      )
-    );
-  }
-}
-async function finalizeWorkflowModule(filePath, state) {
-  const transformedSource = (0, import_generator.generate)(t2.file(t2.program(pruneUnusedTopLevelBindings(state.statements), [], "module")), {
-    sourceMaps: false
-  }).code;
-  return {
-    code: await transpileModule(transformedSource, filePath),
-    workflows: state.workflowExports
-  };
-}
-async function buildTemporalWorkflowModule(sourceText, filePath, _options = {}) {
-  const ast = parseWorkflowModuleAst(sourceText, filePath);
-  const state = createWorkflowTransformState(ast.program);
-  collectWorkflowTransformMetadata(ast.program, state);
-  for (const statement of ast.program.body) {
-    rewriteWorkflowStatement(statement, filePath, state);
-  }
-  appendMissingWorkflowCommits(state);
-  return finalizeWorkflowModule(filePath, state);
-}
-
-// src/webpack-loader.ts
-async function writeDebugModule(resourcePath, code, options) {
-  if (!options.debugOutputDir) {
-    return;
-  }
-  const baseDir = options.entryFile ? import_node_path3.default.dirname(options.entryFile) : process.cwd();
-  const relativePath = import_node_path3.default.relative(baseDir, resourcePath);
-  const safeRelativePath = relativePath.startsWith("..") ? import_node_path3.default.basename(resourcePath) : relativePath;
-  const outputPath = import_node_path3.default.join(options.debugOutputDir, "modules", safeRelativePath);
-  await (0, import_promises.mkdir)(import_node_path3.default.dirname(outputPath), { recursive: true });
-  await (0, import_promises.writeFile)(outputPath, code, "utf-8");
-}
-function mastraTemporalWorkflowLoader(source) {
-  const callback = this.async();
-  if (!callback) {
-    throw new Error("mastra-temporal-webpack-loader requires async mode");
-  }
-  const options = this.getOptions?.() ?? {};
-  if (!source.includes("createWorkflow")) {
-    return callback(null, source);
-  }
-  const transform = async () => {
-    const result = await buildTemporalWorkflowModule(source, this.resourcePath, options);
-    options.registry?.register(
-      this.resourcePath,
-      result.workflows.map((workflow) => workflow.exportName)
-    );
-    return result.code;
-  };
-  transform().then(async (code) => {
-    await writeDebugModule(this.resourcePath, code, options);
-    callback(null, code);
-  }).catch((err) => callback(err));
-}
-//# sourceMappingURL=webpack-loader.cjs.map