@mastra/temporal 0.0.0-observe-20260504181920

package/dist/mastra-deployer-YVT5GB5G.cjs

@@ -0,0 +1,41 @@
+'use strict';
+
+var bundler = require('@mastra/deployer/bundler');
+
+// src/mastra-deployer.ts
+var BuildBundler = class extends bundler.Bundler {
+  constructor() {
+    super("Temporal");
+    this.platform = process.versions?.bun ? "neutral" : "node";
+  }
+  async getUserBundlerOptions(mastraEntryFile, outputDirectory) {
+    const bundlerOptions = await super.getUserBundlerOptions(mastraEntryFile, outputDirectory);
+    return {
+      ...bundlerOptions,
+      externals: true,
+      sourcemap: true
+    };
+  }
+  getEnvFiles() {
+    return Promise.resolve([]);
+  }
+  installDependencies() {
+    return Promise.resolve();
+  }
+  copyPublic() {
+    return Promise.resolve();
+  }
+  writePackageJson() {
+    return Promise.resolve();
+  }
+  async bundle(entryFile, outputDirectory, { toolsPaths, projectRoot }) {
+    return this._bundle(entryFile, entryFile, { outputDirectory, projectRoot }, toolsPaths);
+  }
+  async lint(entryFile, outputDirectory, toolsPaths) {
+    await super.lint(entryFile, outputDirectory, toolsPaths);
+  }
+};
+
+exports.BuildBundler = BuildBundler;
+//# sourceMappingURL=mastra-deployer-YVT5GB5G.cjs.map
+//# sourceMappingURL=mastra-deployer-YVT5GB5G.cjs.map

package/dist/mastra-deployer-YVT5GB5G.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/mastra-deployer.ts"],"names":["Bundler"],"mappings":";;;;;AAGO,IAAM,YAAA,GAAN,cAA2BA,eAAA,CAAQ;AAAA,EACxC,WAAA,GAAc;AACZ,IAAA,KAAA,CAAM,UAAU,CAAA;AAChB,IAAA,IAAA,CAAK,QAAA,GAAW,OAAA,CAAQ,QAAA,EAAU,GAAA,GAAM,SAAA,GAAY,MAAA;AAAA,EACtD;AAAA,EAEA,MAAgB,qBAAA,CACd,eAAA,EACA,eAAA,EACyC;AACzC,IAAA,MAAM,cAAA,GAAiB,MAAM,KAAA,CAAM,qBAAA,CAAsB,iBAAiB,eAAe,CAAA;AAEzF,IAAA,OAAO;AAAA,MACL,GAAG,cAAA;AAAA,MACH,SAAA,EAAW,IAAA;AAAA,MACX,SAAA,EAAW;AAAA,KACb;AAAA,EACF;AAAA,EAEA,WAAA,GAAiC;AAC/B,IAAA,OAAO,OAAA,CAAQ,OAAA,CAAQ,EAAE,CAAA;AAAA,EAC3B;AAAA,EAEU,mBAAA,GAAqC;AAC7C,IAAA,OAAO,QAAQ,OAAA,EAAQ;AAAA,EACzB;AAAA,EAEU,UAAA,GAA4B;AACpC,IAAA,OAAO,QAAQ,OAAA,EAAQ;AAAA,EACzB;AAAA,EAEA,gBAAA,GAAkC;AAChC,IAAA,OAAO,QAAQ,OAAA,EAAQ;AAAA,EACzB;AAAA,EAEA,MAAM,MAAA,CACJ,SAAA,EACA,iBACA,EAAE,UAAA,EAAY,aAAY,EACX;AACf,IAAA,OAAO,IAAA,CAAK,QAAQ,SAAA,EAAW,SAAA,EAAW,EAAE,eAAA,EAAiB,WAAA,IAAe,UAAU,CAAA;AAAA,EACxF;AAAA,EAEA,MAAM,IAAA,CAAK,SAAA,EAAmB,eAAA,EAAyB,UAAA,EAAkD;AACvG,IAAA,MAAM,KAAA,CAAM,IAAA,CAAK,SAAA,EAAW,eAAA,EAAiB,UAAU,CAAA;AAAA,EACzD;AACF","file":"mastra-deployer-YVT5GB5G.cjs","sourcesContent":["import type { Config } from '@mastra/core/mastra';\nimport { Bundler } from '@mastra/deployer/bundler';\n\nexport class BuildBundler extends Bundler {\n  constructor() {\n    super('Temporal');\n    this.platform = process.versions?.bun ? 'neutral' : 'node';\n  }\n\n  protected async getUserBundlerOptions(\n    mastraEntryFile: string,\n    outputDirectory: string,\n  ): Promise<NonNullable<Config['bundler']>> {\n    const bundlerOptions = await super.getUserBundlerOptions(mastraEntryFile, outputDirectory);\n\n    return {\n      ...bundlerOptions,\n      externals: true,\n      sourcemap: true,\n    };\n  }\n\n  getEnvFiles(): Promise<string[]> {\n    return Promise.resolve([]);\n  }\n\n  protected installDependencies(): Promise<void> {\n    return Promise.resolve();\n  }\n\n  protected copyPublic(): Promise<void> {\n    return Promise.resolve();\n  }\n\n  writePackageJson(): Promise<void> {\n    return Promise.resolve();\n  }\n\n  async bundle(\n    entryFile: string,\n    outputDirectory: string,\n    { toolsPaths, projectRoot }: { toolsPaths: (string | string[])[]; projectRoot: string },\n  ): Promise<void> {\n    return this._bundle(entryFile, entryFile, { outputDirectory, projectRoot }, toolsPaths);\n  }\n\n  async lint(entryFile: string, outputDirectory: string, toolsPaths: (string | string[])[]): Promise<void> {\n    await super.lint(entryFile, outputDirectory, toolsPaths);\n  }\n}\n"]}

package/dist/mastra-deployer.d.ts

@@ -0,0 +1,16 @@
+import type { Config } from '@mastra/core/mastra';
+import { Bundler } from '@mastra/deployer/bundler';
+export declare class BuildBundler extends Bundler {
+    constructor();
+    protected getUserBundlerOptions(mastraEntryFile: string, outputDirectory: string): Promise<NonNullable<Config['bundler']>>;
+    getEnvFiles(): Promise<string[]>;
+    protected installDependencies(): Promise<void>;
+    protected copyPublic(): Promise<void>;
+    writePackageJson(): Promise<void>;
+    bundle(entryFile: string, outputDirectory: string, { toolsPaths, projectRoot }: {
+        toolsPaths: (string | string[])[];
+        projectRoot: string;
+    }): Promise<void>;
+    lint(entryFile: string, outputDirectory: string, toolsPaths: (string | string[])[]): Promise<void>;
+}
+//# sourceMappingURL=mastra-deployer.d.ts.map

package/dist/mastra-deployer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mastra-deployer.d.ts","sourceRoot":"","sources":["../src/mastra-deployer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAEnD,qBAAa,YAAa,SAAQ,OAAO;;cAMvB,qBAAqB,CACnC,eAAe,EAAE,MAAM,EACvB,eAAe,EAAE,MAAM,GACtB,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC;IAU1C,WAAW,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAIhC,SAAS,CAAC,mBAAmB,IAAI,OAAO,CAAC,IAAI,CAAC;IAI9C,SAAS,CAAC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAIrC,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B,MAAM,CACV,SAAS,EAAE,MAAM,EACjB,eAAe,EAAE,MAAM,EACvB,EAAE,UAAU,EAAE,WAAW,EAAE,EAAE;QAAE,UAAU,EAAE,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC,EAAE,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,GACtF,OAAO,CAAC,IAAI,CAAC;IAIV,IAAI,CAAC,SAAS,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,EAAE,UAAU,EAAE,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;CAGzG"}

package/dist/plugin.d.ts

@@ -0,0 +1,16 @@
+import type { WorkerOptions, WorkerPlugin } from '@temporalio/worker';
+export declare class MastraPlugin implements WorkerPlugin {
+    #private;
+    name: string;
+    constructor();
+    prebuild({ entryFile, projectRoot, }: {
+        entryFile: string;
+        projectRoot?: string;
+    }): Promise<ReturnType<typeof this.getTemporalWorkerOptions>>;
+    getTemporalWorkerOptions(temporalOutputDir: string): {
+        workflowsPath: WorkerOptions['workflowsPath'];
+        activities: WorkerOptions['activities'];
+    };
+    configureWorker(options: WorkerOptions): WorkerOptions;
+}
+//# sourceMappingURL=plugin.d.ts.map

package/dist/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAsBtE,qBAAa,YAAa,YAAW,YAAY;;IAG/C,IAAI,SAAY;;IAiBV,QAAQ,CAAC,EACb,SAAS,EACT,WAA2B,GAC5B,EAAE;QACD,SAAS,EAAE,MAAM,CAAC;QAClB,WAAW,CAAC,EAAE,MAAM,CAAC;KACtB,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,IAAI,CAAC,wBAAwB,CAAC,CAAC;IAoE7D,wBAAwB,CAAC,iBAAiB,EAAE,MAAM,GAAG;QAEnD,aAAa,EAAE,aAAa,CAAC,eAAe,CAAC,CAAC;QAC9C,UAAU,EAAE,aAAa,CAAC,YAAY,CAAC,CAAC;KACzC;IAeD,eAAe,CAAC,OAAO,EAAE,aAAa,GAAG,aAAa;CAYvD"}

package/dist/run.d.ts

@@ -0,0 +1,24 @@
+import type { RequestContext } from '@mastra/core/di';
+import { Run } from '@mastra/core/workflows';
+import type { Step, WorkflowResult, WorkflowRunStartOptions } from '@mastra/core/workflows';
+import type { Client } from '@temporalio/client';
+import type { TemporalEngineType } from './types.js';
+type TemporalRunStartArgs<TState, TInput, TRequestContext> = {
+    inputData?: TInput;
+    initialState?: TState;
+    requestContext?: RequestContext<TRequestContext>;
+} & WorkflowRunStartOptions;
+export declare class TemporalRun<TSteps extends Step<string, any, any, any, any, any, TemporalEngineType, any>[] = Step<string, unknown, unknown, unknown, unknown, unknown, TemporalEngineType>[], TState = unknown, TInput = unknown, TOutput = unknown, TRequestContext extends Record<string, any> | unknown = unknown> extends Run<TemporalEngineType, TSteps, TState, TInput, TOutput, TRequestContext> {
+    private readonly client;
+    private readonly taskQueue;
+    constructor(params: ConstructorParameters<typeof Run<TemporalEngineType, TSteps, TState, TInput, TOutput, TRequestContext>>[0], temporalParams: {
+        client: Client;
+        taskQueue: string;
+    });
+    start(args?: TemporalRunStartArgs<TState, TInput, TRequestContext>): Promise<WorkflowResult<TState, TInput, TOutput, TSteps>>;
+    startAsync(args?: TemporalRunStartArgs<TState, TInput, TRequestContext>): Promise<{
+        runId: string;
+    }>;
+}
+export {};
+//# sourceMappingURL=run.d.ts.map

package/dist/run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../src/run.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,EAAE,GAAG,EAAE,MAAM,wBAAwB,CAAC;AAC7C,OAAO,KAAK,EAAE,IAAI,EAAE,cAAc,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AAC5F,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAGlD,KAAK,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,eAAe,IAAI;IAC3D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,cAAc,CAAC,EAAE,cAAc,CAAC,eAAe,CAAC,CAAC;CAClD,GAAG,uBAAuB,CAAC;AAE5B,qBAAa,WAAW,CACtB,MAAM,SAAS,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,kBAAkB,EAAE,GAAG,CAAC,EAAE,GAAG,IAAI,CACpF,MAAM,EACN,OAAO,EACP,OAAO,EACP,OAAO,EACP,OAAO,EACP,OAAO,EACP,kBAAkB,CACnB,EAAE,EACH,MAAM,GAAG,OAAO,EAChB,MAAM,GAAG,OAAO,EAChB,OAAO,GAAG,OAAO,EACjB,eAAe,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,OAAO,GAAG,OAAO,CAC/D,SAAQ,GAAG,CAAC,kBAAkB,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,CAAC;IACjF,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;gBAGjC,MAAM,EAAE,qBAAqB,CAAC,OAAO,GAAG,CAAC,kBAAkB,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,EAClH,cAAc,EAAE;QACd,MAAM,EAAE,MAAM,CAAC;QACf,SAAS,EAAE,MAAM,CAAC;KACnB;IAQG,KAAK,CAAC,IAAI,GAAE,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,eAAe,CAAM;IA0CtE,UAAU,CAAC,IAAI,GAAE,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,eAAe,CAAM;;;CAwBlF"}

package/dist/temporal-workflow-runtime.mjs

@@ -0,0 +1,295 @@
+import { executeChild, proxyActivities, log, sleep } from '@temporalio/workflow';
+
+export class TemporalExecutionEngine {
+  startToCloseTimeout;
+  activityHandle;
+
+  constructor(params) {
+    this.startToCloseTimeout = params?.options?.startToCloseTimeout ?? '1 minute';
+    this.activityHandle = proxyActivities({ startToCloseTimeout: this.startToCloseTimeout });
+  }
+
+  async execute(params) {
+    let result = params.input;
+    const stepResults = {};
+
+    for (const entry of params.graph.steps) {
+      result = await this.executeEntry(entry, result, stepResults);
+    }
+
+    return {
+      status: 'success',
+      input: params.input,
+      result,
+      state: params.initialState,
+      steps: stepResults,
+    };
+  }
+
+  async executeEntry(entry, inputData, stepResults) {
+    switch (entry.type) {
+      case 'step': {
+        log.info('step', { stepId: entry.step.id });
+        const out = await this.activityHandle[entry.step.id]({ inputData });
+        stepResults[entry.step.id] = out;
+        return out;
+      }
+
+      case 'childWorkflow': {
+        log.info('childWorkflow', { workflowType: entry.workflowType });
+        const childResult = await executeChild(entry.workflowType, { args: [{ inputData }] });
+        const out = childResult?.result ?? childResult;
+        stepResults[entry.workflowType] = out;
+        return out;
+      }
+
+      case 'sleep': {
+        const duration = entry.duration ?? (entry.fn ? await this.activityHandle[entry.fn]({ inputData }) : 0);
+        log.info('sleep', { id: entry.id, duration });
+        await sleep(duration);
+        return inputData;
+      }
+
+      case 'sleepUntil': {
+        const date =
+          entry.date != null
+            ? new Date(entry.date)
+            : entry.fn
+              ? new Date(await this.activityHandle[entry.fn]({ inputData }))
+              : new Date();
+        log.info('sleepUntil', { id: entry.id, date: date.toISOString() });
+        const duration = Math.max(0, date.getTime() - Date.now());
+        await sleep(duration);
+        return inputData;
+      }
+
+      case 'parallel': {
+        log.info('parallel', { steps: entry.steps.map(s => s.step.id) });
+        const results = await Promise.all(entry.steps.map(s => this.activityHandle[s.step.id]({ inputData })));
+        const out = {};
+
+        entry.steps.forEach((s, i) => {
+          out[s.step.id] = results[i];
+          stepResults[s.step.id] = results[i];
+        });
+
+        return out;
+      }
+
+      case 'conditional': {
+        log.info('conditional', {
+          conditions: entry.serializedConditions.map(condition => condition.id),
+        });
+        const condResults = await Promise.all(
+          entry.serializedConditions.map(condition => this.activityHandle[condition.id]({ inputData })),
+        );
+        const out = {};
+
+        for (let i = 0; i < entry.steps.length; i++) {
+          if (condResults[i]) {
+            const stepId = entry.steps[i].step.id;
+            const res = await this.activityHandle[stepId]({ inputData });
+            out[stepId] = res;
+            stepResults[stepId] = res;
+          }
+        }
+
+        return out;
+      }
+
+      case 'loop': {
+        log.info('loop', { step: entry.step.id, loopType: entry.loopType });
+        let current = inputData;
+
+        while (true) {
+          current = await this.activityHandle[entry.step.id]({ inputData: current });
+          stepResults[entry.step.id] = current;
+          const shouldContinue = Boolean(
+            await this.activityHandle[entry.serializedCondition.id]({ inputData: current }),
+          );
+
+          if (entry.loopType === 'dowhile' ? !shouldContinue : shouldContinue) {
+            break;
+          }
+        }
+
+        return current;
+      }
+
+      case 'foreach': {
+        log.info('foreach', { step: entry.step.id, concurrency: entry.opts.concurrency });
+        const items = Array.isArray(inputData) ? inputData : [];
+        const concurrency = Math.max(1, entry.opts.concurrency ?? 1);
+        const results = new Array(items.length);
+        let index = 0;
+        const workers = Array.from({ length: Math.min(concurrency, items.length) }, async () => {
+          while (true) {
+            const i = index++;
+            if (i >= items.length) {
+              break;
+            }
+            results[i] = await this.activityHandle[entry.step.id]({ inputData: items[i] });
+          }
+        });
+
+        await Promise.all(workers);
+        stepResults[entry.step.id] = results;
+        return results;
+      }
+
+      default:
+        return inputData;
+    }
+  }
+}
+
+export function createWorkflow(workflowId) {
+  const stepFlow = [];
+  let autoId = 0;
+  const nextId = prefix => `${prefix}_${autoId++}`;
+
+  const workflow = async startArgs => {
+    const engine = new TemporalExecutionEngine({
+      options: {
+        startToCloseTimeout: '1 minute',
+      },
+    });
+
+    return engine.execute({
+      workflowId,
+      runId: startArgs?.runId,
+      resourceId: startArgs?.resourceId,
+      graph: {
+        id: workflowId,
+        steps: stepFlow,
+      },
+      input: startArgs?.inputData,
+      initialState: startArgs?.initialState,
+    });
+  };
+
+  return Object.assign(workflow, {
+    then(stepId) {
+      stepFlow.push({
+        type: 'step',
+        step: {
+          id: stepId,
+        },
+      });
+      return workflow;
+    },
+    thenWorkflow(workflowType) {
+      stepFlow.push({
+        type: 'childWorkflow',
+        workflowType,
+      });
+      return workflow;
+    },
+    sleep(durationOrFnId) {
+      if (typeof durationOrFnId === 'number') {
+        stepFlow.push({
+          type: 'sleep',
+          id: nextId('sleep'),
+          duration: durationOrFnId,
+        });
+      } else {
+        stepFlow.push({
+          type: 'sleep',
+          id: nextId('sleep'),
+          fn: durationOrFnId,
+        });
+      }
+      return workflow;
+    },
+    sleepUntil(dateOrFnId) {
+      if (dateOrFnId instanceof Date) {
+        stepFlow.push({
+          type: 'sleepUntil',
+          id: nextId('sleepUntil'),
+          date: dateOrFnId.toISOString(),
+        });
+      } else if (typeof dateOrFnId === 'number' || (typeof dateOrFnId === 'string' && !isNaN(Date.parse(dateOrFnId)))) {
+        stepFlow.push({
+          type: 'sleepUntil',
+          id: nextId('sleepUntil'),
+          date: new Date(dateOrFnId).toISOString(),
+        });
+      } else {
+        stepFlow.push({
+          type: 'sleepUntil',
+          id: nextId('sleepUntil'),
+          fn: dateOrFnId,
+        });
+      }
+      return workflow;
+    },
+    parallel(stepIds) {
+      stepFlow.push({
+        type: 'parallel',
+        steps: stepIds.map(id => ({
+          type: 'step',
+          step: {
+            id,
+          },
+        })),
+      });
+      return workflow;
+    },
+    branch(pairs) {
+      stepFlow.push({
+        type: 'conditional',
+        serializedConditions: pairs.map(pair => ({
+          id: pair[0],
+        })),
+        steps: pairs.map(pair => ({
+          type: 'step',
+          step: {
+            id: pair[1],
+          },
+        })),
+      });
+      return workflow;
+    },
+    dowhile(stepId, condId) {
+      stepFlow.push({
+        type: 'loop',
+        step: {
+          id: stepId,
+        },
+        serializedCondition: {
+          id: condId,
+        },
+        loopType: 'dowhile',
+      });
+      return workflow;
+    },
+    dountil(stepId, condId) {
+      stepFlow.push({
+        type: 'loop',
+        step: {
+          id: stepId,
+        },
+        serializedCondition: {
+          id: condId,
+        },
+        loopType: 'dountil',
+      });
+      return workflow;
+    },
+    foreach(stepId, opts) {
+      stepFlow.push({
+        type: 'foreach',
+        step: {
+          id: stepId,
+        },
+        opts: {
+          concurrency: opts?.concurrency ?? 1,
+        },
+      });
+      return workflow;
+    },
+    commit() {
+      return workflow;
+    },
+  });
+}

package/dist/transforms/activities.d.ts

@@ -0,0 +1,11 @@
+export interface TemporalActivityBinding {
+    exportName: string;
+    stepId: string;
+}
+export interface BuildTemporalActivitiesModuleResult {
+    outputPath: string;
+    activityBindings: TemporalActivityBinding[];
+}
+export declare function collectTemporalActivityBindings(sourceText: string, filePath: string): TemporalActivityBinding[];
+export declare function buildTemporalActivitiesModule(entryFile: string, outputDirectory: string, outputFileName: string): Promise<BuildTemporalActivitiesModuleResult>;
+//# sourceMappingURL=activities.d.ts.map

package/dist/transforms/activities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activities.d.ts","sourceRoot":"","sources":["../../src/transforms/activities.ts"],"names":[],"mappings":"AAsBA,MAAM,WAAW,uBAAuB;IACtC,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,mCAAmC;IAClD,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,uBAAuB,EAAE,CAAC;CAC7C;AAED,wBAAgB,+BAA+B,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,uBAAuB,EAAE,CAkE/G;AA6HD,wBAAsB,6BAA6B,CACjD,SAAS,EAAE,MAAM,EACjB,eAAe,EAAE,MAAM,EACvB,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,mCAAmC,CAAC,CA0T9C"}

package/dist/transforms/shared.d.ts

@@ -0,0 +1,23 @@
+import * as t from '@babel/types';
+export declare const parserPlugins: readonly ["typescript", "jsx", "classProperties", "classPrivateProperties", "classPrivateMethods", "topLevelAwait", "importAttributes", "decorators-legacy"];
+export declare function parseModule(filePath: string, sourceText?: string): t.File;
+export declare function isIdentifierNamed(node: t.Node, name: string): boolean;
+export declare function isTemporalHelperModule(source: string): boolean;
+export declare const strippedExternalModules: Set<string>;
+export declare function isStrippedExternalModule(source: string): boolean;
+export declare function collectImportedNames(statement: t.ImportDeclaration): Set<string>;
+export declare function nodeReferencesName(node: t.Node, names: Set<string>): boolean;
+export declare function isWorkflowHelperDestructure(declaration: t.VariableDeclarator): boolean;
+export declare function isCreateWorkflowCall(node: t.Node): node is t.CallExpression;
+export declare function isCreateStepCall(node: t.Node): node is t.CallExpression;
+export declare function getObjectPropertyName(property: t.ObjectProperty | t.ObjectMethod): string | null;
+export declare function walk(node: t.Node | null | undefined, visitor: (node: t.Node) => false | void): void;
+export declare function hasCreateWorkflowCall(node: t.Node): boolean;
+export declare function getStepNameFromCall(node: t.CallExpression): string | null;
+export declare function createExportedStepStatement(name: string, initializer: t.Expression): t.ExportNamedDeclaration;
+export declare function collectInlineCreateSteps(node: t.Node, seenNames: Set<string>, statements: t.Statement[], onStep?: (exportName: string, call: t.CallExpression) => void): void;
+export declare function getCreateStepId(node: t.Node | null | undefined): string | null;
+export declare function shouldCountIdentifierAsReference(parent: t.Node | null, key: string | null): boolean;
+export declare function collectRuntimeReferencedIdentifiers(node: t.Node): Set<string>;
+export declare function pruneUnusedTopLevelBindings(statements: t.Statement[]): t.Statement[];
+//# sourceMappingURL=shared.d.ts.map

package/dist/transforms/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../src/transforms/shared.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,cAAc,CAAC;AAElC,eAAO,MAAM,aAAa,8JAShB,CAAC;AACX,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,IAAI,CAUzE;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAErE;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAE9D;AAED,eAAO,MAAM,uBAAuB,aAA2D,CAAC;AAEhG,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAEhE;AAED,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,CAAC,CAAC,iBAAiB,GAAG,GAAG,CAAC,MAAM,CAAC,CAgBhF;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,OAAO,CAW5E;AAED,wBAAgB,2BAA2B,CAAC,WAAW,EAAE,CAAC,CAAC,kBAAkB,GAAG,OAAO,CAYtF;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,GAAG,IAAI,IAAI,CAAC,CAAC,cAAc,CAE3E;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,GAAG,IAAI,IAAI,CAAC,CAAC,cAAc,CAEvE;AAED,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,CAAC,CAAC,cAAc,GAAG,CAAC,CAAC,YAAY,GAAG,MAAM,GAAG,IAAI,CAchG;AAED,wBAAgB,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,GAAG,IAAI,GAAG,SAAS,EAAE,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,KAAK,KAAK,GAAG,IAAI,GAAG,IAAI,CA2BnG;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,GAAG,OAAO,CAW3D;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,CAAC,CAAC,cAAc,GAAG,MAAM,GAAG,IAAI,CAUzE;AAED,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC,CAAC,UAAU,GAAG,CAAC,CAAC,sBAAsB,CAI7G;AAED,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,CAAC,CAAC,IAAI,EACZ,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,EACtB,UAAU,EAAE,CAAC,CAAC,SAAS,EAAE,EACzB,MAAM,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,cAAc,KAAK,IAAI,GAC5D,IAAI,CAgBN;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAwB9E;AAED,wBAAgB,gCAAgC,CAAC,MAAM,EAAE,CAAC,CAAC,IAAI,GAAG,IAAI,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CA+DnG;AAED,wBAAgB,mCAAmC,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,GAAG,GAAG,CAAC,MAAM,CAAC,CAsC7E;AAED,wBAAgB,2BAA2B,CAAC,UAAU,EAAE,CAAC,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC,SAAS,EAAE,CA4IpF"}

package/dist/transforms/temporal-workflow-runtime.d.mts

@@ -0,0 +1,92 @@
+export function createWorkflow(workflowId: any): ((startArgs: any) => Promise<{
+    status: string;
+    input: any;
+    result: any;
+    state: any;
+    steps: {};
+}>) & {
+    then(stepId: any): (startArgs: any) => Promise<{
+        status: string;
+        input: any;
+        result: any;
+        state: any;
+        steps: {};
+    }>;
+    thenWorkflow(workflowType: any): (startArgs: any) => Promise<{
+        status: string;
+        input: any;
+        result: any;
+        state: any;
+        steps: {};
+    }>;
+    sleep(durationOrFnId: any): (startArgs: any) => Promise<{
+        status: string;
+        input: any;
+        result: any;
+        state: any;
+        steps: {};
+    }>;
+    sleepUntil(dateOrFnId: any): (startArgs: any) => Promise<{
+        status: string;
+        input: any;
+        result: any;
+        state: any;
+        steps: {};
+    }>;
+    parallel(stepIds: any): (startArgs: any) => Promise<{
+        status: string;
+        input: any;
+        result: any;
+        state: any;
+        steps: {};
+    }>;
+    branch(pairs: any): (startArgs: any) => Promise<{
+        status: string;
+        input: any;
+        result: any;
+        state: any;
+        steps: {};
+    }>;
+    dowhile(stepId: any, condId: any): (startArgs: any) => Promise<{
+        status: string;
+        input: any;
+        result: any;
+        state: any;
+        steps: {};
+    }>;
+    dountil(stepId: any, condId: any): (startArgs: any) => Promise<{
+        status: string;
+        input: any;
+        result: any;
+        state: any;
+        steps: {};
+    }>;
+    foreach(stepId: any, opts: any): (startArgs: any) => Promise<{
+        status: string;
+        input: any;
+        result: any;
+        state: any;
+        steps: {};
+    }>;
+    commit(): (startArgs: any) => Promise<{
+        status: string;
+        input: any;
+        result: any;
+        state: any;
+        steps: {};
+    }>;
+};
+export class TemporalExecutionEngine {
+    constructor(params: any);
+    startToCloseTimeout: any;
+    activityHandle: import("@temporalio/workflow").ActivityInterfaceFor<import("@temporalio/workflow").UntypedActivities>;
+    execute(params: any): Promise<{
+        status: string;
+        input: any;
+        result: any;
+        state: any;
+        steps: {};
+    }>;
+    executeEntry(entry: any, inputData: any, stepResults: any): Promise<any>;
+}
+//# sourceMappingURL=temporal-workflow-runtime.d.mts.map

package/dist/transforms/temporal-workflow-runtime.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"temporal-workflow-runtime.d.mts","sourceRoot":"","sources":["../../src/transforms/temporal-workflow-runtime.mjs"],"names":[],"mappings":"AAiJA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqJC;AApSD;IAIE,yBAGC;IAND,yBAAoB;IACpB,sHAAe;IAOf;;;;;;OAeC;IAED,yEAkHC;CACF"}

package/dist/transforms/workflows.d.ts

@@ -0,0 +1,20 @@
+export interface BuildTemporalWorkflowOptions {
+}
+export interface TemporalWorkflowExport {
+    exportName: string;
+    workflowId: string;
+}
+export interface BuildTemporalWorkflowModuleResult {
+    code: string;
+    workflows: TemporalWorkflowExport[];
+}
+/**
+ * Transforms a user-authored workflow module into a Temporal-friendly module:
+ * - strips Mastra/Temporal setup that cannot run in the workflow sandbox
+ * - rewrites fluent workflow chains into deterministic exported functions
+ * - returns registry metadata so the entry module can re-export the right names
+ */
+export declare function buildTemporalWorkflowModule(entryFile: string, outputDirectory: string, outputFileName: string): Promise<{
+    outputPath: string;
+}>;
+//# sourceMappingURL=workflows.d.ts.map

package/dist/transforms/workflows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflows.d.ts","sourceRoot":"","sources":["../../src/transforms/workflows.ts"],"names":[],"mappings":"AAsYA,MAAM,WAAW,4BAA4B;CAE5C;AAED,MAAM,WAAW,sBAAsB;IACrC,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,iCAAiC;IAChD,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,sBAAsB,EAAE,CAAC;CACrC;AAiUD;;;;;GAKG;AACH,wBAAsB,2BAA2B,CAC/C,SAAS,EAAE,MAAM,EACjB,eAAe,EAAE,MAAM,EACvB,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC;IAAE,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC,CAwCjC"}

package/dist/types.d.ts

@@ -0,0 +1,4 @@
+export type TemporalEngineType = {
+    step: any;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,GAAG,CAAC;CACX,CAAC"}

package/dist/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function toWorkflowType(id: string): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,UAGxC"}