@workflow/core 4.0.1-beta.9 → 4.1.0-beta.52

package/dist/runtime.js

@@ -1,169 +1,24 @@
-import { waitUntil } from '@vercel/functions';
-import { FatalError, RetryableError, WorkflowAPIError, WorkflowRunCancelledError, WorkflowRunFailedError, WorkflowRunNotCompletedError, WorkflowRuntimeError, } from '@workflow/errors';
+import { WorkflowRuntimeError } from '@workflow/errors';
+import { parseWorkflowName } from '@workflow/utils/parse-name';
+import { SPEC_VERSION_CURRENT, WorkflowInvokePayloadSchema, } from '@workflow/world';
 import { WorkflowSuspension } from './global.js';
 import { runtimeLogger } from './logger.js';
-import { getStepFunction } from './private.js';
+import { getAllWorkflowRunEvents, getQueueOverhead, handleHealthCheckMessage, parseHealthCheckPayload, withHealthCheck, } from './runtime/helpers.js';
+import { handleSuspension } from './runtime/suspension-handler.js';
 import { getWorld, getWorldHandlers } from './runtime/world.js';
-import { StepInvokePayloadSchema, WorkflowInvokePayloadSchema, } from './schemas.js';
-import { dehydrateStepArguments, dehydrateStepReturnValue, getExternalRevivers, hydrateStepArguments, hydrateWorkflowReturnValue, } from './serialization.js';
-// TODO: move step handler out to a separate file
-import { contextStorage } from './step/context-storage.js';
+import { remapErrorStack } from './source-map.js';
 import * as Attribute from './telemetry/semantic-conventions.js';
-import { serializeTraceCarrier, trace, withTraceContext } from './telemetry.js';
+import { linkToCurrentContext, trace, withTraceContext } from './telemetry.js';
 import { getErrorName, getErrorStack } from './types.js';
-import { buildWorkflowSuspensionMessage, getWorkflowRunStreamId, } from './util.js';
+import { buildWorkflowSuspensionMessage } from './util.js';
 import { runWorkflow } from './workflow.js';
 export { WorkflowSuspension } from './global.js';
+export { healthCheck, } from './runtime/helpers.js';
 export { getHookByToken, resumeHook, resumeWebhook, } from './runtime/resume-hook.js';
 export { start } from './runtime/start.js';
+export { stepEntrypoint } from './runtime/step-handler.js';
 export { createWorld, getWorld, getWorldHandlers, setWorld, } from './runtime/world.js';
-/**
- * A handler class for a workflow run.
- */
-export class Run {
-    /**
-     * The ID of the workflow run.
-     */
-    runId;
-    /**
-     * The world object.
-     * @internal
-     */
-    world;
-    constructor(runId) {
-        this.runId = runId;
-        this.world = getWorld();
-    }
-    /**
-     * Cancels the workflow run.
-     */
-    async cancel() {
-        await this.world.runs.cancel(this.runId);
-    }
-    /**
-     * The status of the workflow run.
-     */
-    get status() {
-        return this.world.runs.get(this.runId).then((run) => run.status);
-    }
-    /**
-     * The return value of the workflow run.
-     * Polls the workflow return value until it is completed.
-     */
-    get returnValue() {
-        return this.pollReturnValue();
-    }
-    /**
-     * The name of the workflow.
-     */
-    get workflowName() {
-        return this.world.runs.get(this.runId).then((run) => run.workflowName);
-    }
-    /**
-     * The timestamp when the workflow run was created.
-     */
-    get createdAt() {
-        return this.world.runs.get(this.runId).then((run) => run.createdAt);
-    }
-    /**
-     * The timestamp when the workflow run started execution.
-     * Returns undefined if the workflow has not started yet.
-     */
-    get startedAt() {
-        return this.world.runs.get(this.runId).then((run) => run.startedAt);
-    }
-    /**
-     * The timestamp when the workflow run completed.
-     * Returns undefined if the workflow has not completed yet.
-     */
-    get completedAt() {
-        return this.world.runs.get(this.runId).then((run) => run.completedAt);
-    }
-    /**
-     * The readable stream of the workflow run.
-     */
-    get readable() {
-        return this.getReadable();
-    }
-    /**
-     * Retrieves the workflow run's default readable stream, which reads chunks
-     * written to the corresponding writable stream {@link getWritable}.
-     *
-     * @param options - The options for the readable stream.
-     * @returns The `ReadableStream` for the workflow run.
-     */
-    getReadable(options = {}) {
-        const { ops = [], global = globalThis, startIndex, namespace } = options;
-        const name = getWorkflowRunStreamId(this.runId, namespace);
-        return getExternalRevivers(global, ops).ReadableStream({
-            name,
-            startIndex,
-        });
-    }
-    /**
-     * Polls the workflow return value every 1 second until it is completed.
-     * @internal
-     * @returns The workflow return value.
-     */
-    async pollReturnValue() {
-        while (true) {
-            try {
-                const run = await this.world.runs.get(this.runId);
-                if (run.status === 'completed') {
-                    return hydrateWorkflowReturnValue(run.output, [], globalThis);
-                }
-                if (run.status === 'cancelled') {
-                    throw new WorkflowRunCancelledError(this.runId);
-                }
-                if (run.status === 'failed') {
-                    throw new WorkflowRunFailedError(this.runId, run.error ?? 'Unknown error');
-                }
-                throw new WorkflowRunNotCompletedError(this.runId, run.status);
-            }
-            catch (error) {
-                if (WorkflowRunNotCompletedError.is(error)) {
-                    await new Promise((resolve) => setTimeout(resolve, 1_000));
-                    continue;
-                }
-                throw error;
-            }
-        }
-    }
-}
-/**
- * Retrieves a `Run` object for a given run ID.
- *
- * @param runId - The workflow run ID obtained from {@link start}.
- * @returns A `Run` object.
- * @throws WorkflowRunNotFoundError if the run ID is not found.
- */
-export function getRun(runId) {
-    return new Run(runId);
-}
-/**
- * Loads all workflow run events by iterating through all pages of paginated results.
- * This ensures that *all* events are loaded into memory before running the workflow.
- * Events must be in chronological order (ascending) for proper workflow replay.
- */
-async function getAllWorkflowRunEvents(runId) {
-    const allEvents = [];
-    let cursor = null;
-    let hasMore = true;
-    const world = getWorld();
-    while (hasMore) {
-        const response = await world.events.list({
-            runId,
-            pagination: {
-                sortOrder: 'asc', // Required: events must be in chronological order for replay
-                cursor: cursor ?? undefined,
-            },
-        });
-        allEvents.push(...response.data);
-        hasMore = response.hasMore;
-        cursor = response.cursor;
-    }
-    return allEvents;
-}
+export { getRun, Run, } from './runtime/run.js';
 /**
  * Function that creates a single route which handles any workflow execution
  * request and routes to the appropriate workflow function.
@@ -173,18 +28,30 @@ async function getAllWorkflowRunEvents(runId) {
  * @returns A function that can be used as a Vercel API route.
  */
 export function workflowEntrypoint(workflowCode) {
-    return getWorldHandlers().createQueueHandler('__wkf_workflow_', async (message_, metadata) => {
-        const { runId, traceCarrier: traceContext } = WorkflowInvokePayloadSchema.parse(message_);
+    const handler = getWorldHandlers().createQueueHandler('__wkf_workflow_', async (message_, metadata) => {
+        // Check if this is a health check message
+        // NOTE: Health check messages are intentionally unauthenticated for monitoring purposes.
+        // They only write a simple status response to a stream and do not expose sensitive data.
+        // The stream name includes a unique correlationId that must be known by the caller.
+        const healthCheck = parseHealthCheckPayload(message_);
+        if (healthCheck) {
+            await handleHealthCheckMessage(healthCheck, 'workflow');
+            return;
+        }
+        const { runId, traceCarrier: traceContext, requestedAt, } = WorkflowInvokePayloadSchema.parse(message_);
         // Extract the workflow name from the topic name
         const workflowName = metadata.queueName.slice('__wkf_workflow_'.length);
+        const spanLinks = await linkToCurrentContext();
         // Invoke user workflow within the propagated trace context
         return await withTraceContext(traceContext, async () => {
             const world = getWorld();
-            return trace(`WORKFLOW ${workflowName}`, async (span) => {
+            return trace(`WORKFLOW ${workflowName}`, { links: spanLinks }, async (span) => {
                 span?.setAttributes({
                     ...Attribute.WorkflowName(workflowName),
                     ...Attribute.WorkflowOperation('execute'),
                     ...Attribute.QueueName(metadata.queueName),
+                    ...Attribute.QueueMessageId(metadata.messageId),
+                    ...getQueueOverhead({ requestedAt }),
                 });
                 // TODO: validate `workflowName` exists before consuming message?
                 span?.setAttributes({
@@ -195,15 +62,21 @@ export function workflowEntrypoint(workflowCode) {
                 try {
                     let workflowRun = await world.runs.get(runId);
                     if (workflowRun.status === 'pending') {
-                        workflowRun = await world.runs.update(runId, {
-                            // This sets the `startedAt` timestamp at the database level
-                            status: 'running',
+                        // Transition run to 'running' via event (event-sourced architecture)
+                        const result = await world.events.create(runId, {
+                            eventType: 'run_started',
+                            specVersion: SPEC_VERSION_CURRENT,
                         });
+                        // Use the run entity from the event response (no extra get call needed)
+                        if (!result.run) {
+                            throw new WorkflowRuntimeError(`Event creation for 'run_started' did not return the run entity for run \"${runId}\"`);
+                        }
+                        workflowRun = result.run;
                     }
                     // At this point, the workflow is "running" and `startedAt` should
                     // definitely be set.
                     if (!workflowRun.startedAt) {
-                        throw new Error(`Workflow run "${runId}" has no "startedAt" timestamp`);
+                        throw new WorkflowRuntimeError(`Workflow run "${runId}" has no "startedAt" timestamp`);
                     }
                     workflowStartedAt = +workflowRun.startedAt;
                     span?.setAttributes({
@@ -224,27 +97,35 @@ export function workflowEntrypoint(workflowCode) {
                     const events = await getAllWorkflowRunEvents(workflowRun.runId);
                     // Check for any elapsed waits and create wait_completed events
                     const now = Date.now();
-                    for (const event of events) {
-                        if (event.eventType === 'wait_created') {
-                            const resumeAt = event.eventData.resumeAt;
-                            const hasCompleted = events.some((e) => e.eventType === 'wait_completed' &&
-                                e.correlationId === event.correlationId);
-                            // If wait has elapsed and hasn't been completed yet
-                            if (!hasCompleted && now >= resumeAt.getTime()) {
-                                const completedEvent = await world.events.create(runId, {
-                                    eventType: 'wait_completed',
-                                    correlationId: event.correlationId,
-                                });
-                                // Add the event to the events array so the workflow can see it
-                                events.push(completedEvent);
-                            }
-                        }
+                    // Pre-compute completed correlation IDs for O(n) lookup instead of O(n²)
+                    const completedWaitIds = new Set(events
+                        .filter((e) => e.eventType === 'wait_completed')
+                        .map((e) => e.correlationId));
+                    // Collect all waits that need completion
+                    const waitsToComplete = events
+                        .filter((e) => e.eventType === 'wait_created' &&
+                        e.correlationId !== undefined &&
+                        !completedWaitIds.has(e.correlationId) &&
+                        now >= e.eventData.resumeAt.getTime())
+                        .map((e) => ({
+                        eventType: 'wait_completed',
+                        specVersion: SPEC_VERSION_CURRENT,
+                        correlationId: e.correlationId,
+                    }));
+                    // Create all wait_completed events
+                    for (const waitEvent of waitsToComplete) {
+                        const result = await world.events.create(runId, waitEvent);
+                        // Add the event to the events array so the workflow can see it
+                        events.push(result.event);
                     }
                     const result = await runWorkflow(workflowCode, workflowRun, events);
-                    // Update the workflow run with the result
-                    await world.runs.update(runId, {
-                        status: 'completed',
-                        output: result,
+                    // Complete the workflow run via event (event-sourced architecture)
+                    await world.events.create(runId, {
+                        eventType: 'run_completed',
+                        specVersion: SPEC_VERSION_CURRENT,
+                        eventData: {
+                            output: result,
+                        },
                     });
                     span?.setAttributes({
                         ...Attribute.WorkflowRunStatus('completed'),
@@ -255,128 +136,45 @@ export function workflowEntrypoint(workflowCode) {
                     if (WorkflowSuspension.is(err)) {
                         const suspensionMessage = buildWorkflowSuspensionMessage(runId, err.stepCount, err.hookCount, err.waitCount);
                         if (suspensionMessage) {
-                            // Note: suspensionMessage logged only in debug mode to avoid production noise
-                            // console.debug(suspensionMessage);
-                        }
-                        // Process each operation in the queue (steps and hooks)
-                        let minTimeoutSeconds = null;
-                        for (const queueItem of err.steps) {
-                            if (queueItem.type === 'step') {
-                                // Handle step operations
-                                const ops = [];
-                                const dehydratedArgs = dehydrateStepArguments(queueItem.args, err.globalThis);
-                                try {
-                                    const step = await world.steps.create(runId, {
-                                        stepId: queueItem.correlationId,
-                                        stepName: queueItem.stepName,
-                                        input: dehydratedArgs,
-                                    });
-                                    waitUntil(Promise.all(ops));
-                                    await world.queue(`__wkf_step_${queueItem.stepName}`, {
-                                        workflowName,
-                                        workflowRunId: runId,
-                                        workflowStartedAt,
-                                        stepId: step.stepId,
-                                        traceCarrier: await serializeTraceCarrier(),
-                                    }, {
-                                        idempotencyKey: queueItem.correlationId,
-                                    });
-                                }
-                                catch (err) {
-                                    if (WorkflowAPIError.is(err) && err.status === 409) {
-                                        // Step already exists, so we can skip it
-                                        console.warn(`Step "${queueItem.stepName}" with correlation ID "${queueItem.correlationId}" already exists, skipping: ${err.message}`);
-                                        continue;
-                                    }
-                                    throw err;
-                                }
-                            }
-                            else if (queueItem.type === 'hook') {
-                                // Handle hook operations
-                                try {
-                                    // Create hook in database
-                                    const hookMetadata = typeof queueItem.metadata === 'undefined'
-                                        ? undefined
-                                        : dehydrateStepArguments(queueItem.metadata, err.globalThis);
-                                    await world.hooks.create(runId, {
-                                        hookId: queueItem.correlationId,
-                                        token: queueItem.token,
-                                        metadata: hookMetadata,
-                                    });
-                                    // Create hook_created event in event log
-                                    await world.events.create(runId, {
-                                        eventType: 'hook_created',
-                                        correlationId: queueItem.correlationId,
-                                    });
-                                }
-                                catch (err) {
-                                    if (WorkflowAPIError.is(err)) {
-                                        if (err.status === 409) {
-                                            // Hook already exists (duplicate hook_id constraint), so we can skip it
-                                            console.warn(`Hook with correlation ID "${queueItem.correlationId}" already exists, skipping: ${err.message}`);
-                                            continue;
-                                        }
-                                        else if (err.status === 410) {
-                                            // Workflow has already completed, so no-op
-                                            console.warn(`Workflow run "${runId}" has already completed, skipping hook "${queueItem.correlationId}": ${err.message}`);
-                                            continue;
-                                        }
-                                    }
-                                    throw err;
-                                }
-                            }
-                            else if (queueItem.type === 'wait') {
-                                // Handle wait operations
-                                try {
-                                    // Only create wait_created event if it hasn't been created yet
-                                    if (!queueItem.hasCreatedEvent) {
-                                        await world.events.create(runId, {
-                                            eventType: 'wait_created',
-                                            correlationId: queueItem.correlationId,
-                                            eventData: {
-                                                resumeAt: queueItem.resumeAt,
-                                            },
-                                        });
-                                    }
-                                    // Calculate how long to wait before resuming
-                                    const now = Date.now();
-                                    const resumeAtMs = queueItem.resumeAt.getTime();
-                                    const delayMs = Math.max(1000, resumeAtMs - now);
-                                    const timeoutSeconds = Math.ceil(delayMs / 1000);
-                                    // Track the minimum timeout across all waits
-                                    if (minTimeoutSeconds === null ||
-                                        timeoutSeconds < minTimeoutSeconds) {
-                                        minTimeoutSeconds = timeoutSeconds;
-                                    }
-                                }
-                                catch (err) {
-                                    if (WorkflowAPIError.is(err) && err.status === 409) {
-                                        // Wait already exists, so we can skip it
-                                        console.warn(`Wait with correlation ID "${queueItem.correlationId}" already exists, skipping: ${err.message}`);
-                                        continue;
-                                    }
-                                    throw err;
-                                }
-                            }
+                            runtimeLogger.debug(suspensionMessage);
                         }
-                        span?.setAttributes({
-                            ...Attribute.WorkflowRunStatus('pending_steps'),
-                            ...Attribute.WorkflowStepsCreated(err.steps.length),
+                        const result = await handleSuspension({
+                            suspension: err,
+                            world,
+                            runId,
+                            workflowName,
+                            workflowStartedAt,
+                            span,
                         });
-                        // If we encountered any waits, return the minimum timeout
-                        if (minTimeoutSeconds !== null) {
-                            return { timeoutSeconds: minTimeoutSeconds };
+                        if (result.timeoutSeconds !== undefined) {
+                            return { timeoutSeconds: result.timeoutSeconds };
                         }
                     }
                     else {
+                        // NOTE: this error could be an error thrown in user code, or could also be a WorkflowRuntimeError
+                        // (for instance when the event log is corrupted, this is thrown by the event consumer). We could
+                        // specially handle these if needed.
                         const errorName = getErrorName(err);
-                        const errorStack = getErrorStack(err);
+                        const errorMessage = err instanceof Error ? err.message : String(err);
+                        let errorStack = getErrorStack(err);
+                        // Remap error stack using source maps to show original source locations
+                        if (errorStack) {
+                            const parsedName = parseWorkflowName(workflowName);
+                            const filename = parsedName?.path || workflowName;
+                            errorStack = remapErrorStack(errorStack, filename, workflowCode);
+                        }
                         console.error(`${errorName} while running "${runId}" workflow:\n\n${errorStack}`);
-                        await world.runs.update(runId, {
-                            status: 'failed',
-                            error: String(err),
-                            // TODO: include error codes when we define them
-                            // TODO: serialize/include the error name and stack?
+                        // Fail the workflow run via event (event-sourced architecture)
+                        await world.events.create(runId, {
+                            eventType: 'run_failed',
+                            specVersion: SPEC_VERSION_CURRENT,
+                            eventData: {
+                                error: {
+                                    message: errorMessage,
+                                    stack: errorStack,
+                                },
+                                // TODO: include error codes when we define them
+                            },
                         });
                         span?.setAttributes({
                             ...Attribute.WorkflowRunStatus('failed'),
@@ -388,241 +186,9 @@ export function workflowEntrypoint(workflowCode) {
             }); // End withTraceContext
         });
     });
+    return withHealthCheck(handler);
 }
-/**
- * A single route that handles any step execution request and routes to the
- * appropriate step function. We may eventually want to create different bundles
- * for each step, this is temporary.
- */
-export const stepEntrypoint = 
-/* @__PURE__ */ getWorldHandlers().createQueueHandler('__wkf_step_', async (message_, metadata) => {
-    const { workflowName, workflowRunId, workflowStartedAt, stepId, traceCarrier: traceContext, } = StepInvokePayloadSchema.parse(message_);
-    // Execute step within the propagated trace context
-    return await withTraceContext(traceContext, async () => {
-        // Extract the step name from the topic name
-        const stepName = metadata.queueName.slice('__wkf_step_'.length);
-        const world = getWorld();
-        return trace(`STEP ${stepName}`, async (span) => {
-            span?.setAttributes({
-                ...Attribute.StepName(stepName),
-                ...Attribute.StepAttempt(metadata.attempt),
-                ...Attribute.QueueName(metadata.queueName),
-            });
-            const stepFn = getStepFunction(stepName);
-            if (!stepFn) {
-                throw new Error(`Step "${stepName}" not found`);
-            }
-            if (typeof stepFn !== 'function') {
-                throw new Error(`Step "${stepName}" is not a function (got ${typeof stepFn})`);
-            }
-            span?.setAttributes({
-                ...Attribute.WorkflowName(workflowName),
-                ...Attribute.WorkflowRunId(workflowRunId),
-                ...Attribute.StepId(stepId),
-                ...Attribute.StepMaxRetries(stepFn.maxRetries ?? 3),
-                ...Attribute.StepTracePropagated(!!traceContext),
-            });
-            let step = await world.steps.get(workflowRunId, stepId);
-            runtimeLogger.debug('Step execution details', {
-                stepName,
-                stepId: step.stepId,
-                status: step.status,
-                attempt: step.attempt,
-            });
-            span?.setAttributes({
-                ...Attribute.StepStatus(step.status),
-            });
-            // Check if the step has a `retryAfter` timestamp that hasn't been reached yet
-            const now = Date.now();
-            if (step.retryAfter && step.retryAfter.getTime() > now) {
-                const timeoutSeconds = Math.ceil((step.retryAfter.getTime() - now) / 1000);
-                span?.setAttributes({
-                    ...Attribute.StepRetryTimeoutSeconds(timeoutSeconds),
-                });
-                runtimeLogger.debug('Step retryAfter timestamp not yet reached', {
-                    stepName,
-                    stepId: step.stepId,
-                    retryAfter: step.retryAfter,
-                    timeoutSeconds,
-                });
-                return { timeoutSeconds };
-            }
-            let result;
-            const attempt = step.attempt + 1;
-            try {
-                if (step.status !== 'pending') {
-                    // We should only be running the step if it's pending
-                    // (initial state, or state set on re-try), so the step has been
-                    // invoked erroneously.
-                    console.error(`[Workflows] "${workflowRunId}" - Step invoked erroneously, expected status "pending", got "${step.status}" instead, skipping execution`);
-                    span?.setAttributes({
-                        ...Attribute.StepSkipped(true),
-                        ...Attribute.StepSkipReason(step.status),
-                    });
-                    return;
-                }
-                await world.events.create(workflowRunId, {
-                    eventType: 'step_started', // TODO: Replace with 'step_retrying'
-                    correlationId: stepId,
-                });
-                step = await world.steps.update(workflowRunId, stepId, {
-                    attempt,
-                    status: 'running',
-                });
-                if (!step.startedAt) {
-                    throw new WorkflowRuntimeError(`Step "${stepId}" has no "startedAt" timestamp`);
-                }
-                // Hydrate the step input arguments
-                const ops = [];
-                const args = hydrateStepArguments(step.input, ops);
-                span?.setAttributes({
-                    ...Attribute.StepArgumentsCount(args.length),
-                });
-                result = await contextStorage.run({
-                    stepMetadata: {
-                        stepId,
-                        stepStartedAt: new Date(+step.startedAt),
-                        attempt,
-                    },
-                    workflowMetadata: {
-                        workflowRunId,
-                        workflowStartedAt: new Date(+workflowStartedAt),
-                        // TODO: there should be a getUrl method on the world interface itself. This
-                        // solution only works for vercel + embedded worlds.
-                        url: process.env.VERCEL_URL
-                            ? `https://${process.env.VERCEL_URL}`
-                            : `http://localhost:${process.env.PORT || 3000}`,
-                    },
-                    ops,
-                }, () => stepFn(...args));
-                result = dehydrateStepReturnValue(result, ops);
-                waitUntil(Promise.all(ops));
-                // Update the event log with the step result
-                await world.events.create(workflowRunId, {
-                    eventType: 'step_completed',
-                    correlationId: stepId,
-                    eventData: {
-                        result: result,
-                    },
-                });
-                await world.steps.update(workflowRunId, stepId, {
-                    status: 'completed',
-                    output: result,
-                });
-                span?.setAttributes({
-                    ...Attribute.StepStatus('completed'),
-                    ...Attribute.StepResultType(typeof result),
-                });
-            }
-            catch (err) {
-                span?.setAttributes({
-                    ...Attribute.StepErrorName(getErrorName(err)),
-                    ...Attribute.StepErrorMessage(String(err)),
-                });
-                if (WorkflowAPIError.is(err)) {
-                    if (err.status === 410) {
-                        // Workflow has already completed, so no-op
-                        console.warn(`Workflow run "${workflowRunId}" has already completed, skipping step "${stepId}": ${err.message}`);
-                        return;
-                    }
-                }
-                if (FatalError.is(err)) {
-                    const stackLines = getErrorStack(err).split('\n').slice(0, 4);
-                    console.error(`[Workflows] "${workflowRunId}" - Encountered \`FatalError\` while executing step "${stepName}":\n  > ${stackLines.join('\n    > ')}\n\nBubbling up error to parent workflow`);
-                    // Fatal error - store the error in the event log and re-invoke the workflow
-                    await world.events.create(workflowRunId, {
-                        eventType: 'step_failed',
-                        correlationId: stepId,
-                        eventData: {
-                            error: String(err),
-                            stack: err.stack,
-                            fatal: true,
-                        },
-                    });
-                    await world.steps.update(workflowRunId, stepId, {
-                        status: 'failed',
-                        error: String(err),
-                        // TODO: include error codes when we define them
-                        // TODO: serialize/include the error name and stack?
-                    });
-                    span?.setAttributes({
-                        ...Attribute.StepStatus('failed'),
-                        ...Attribute.StepFatalError(true),
-                    });
-                }
-                else {
-                    const maxRetries = stepFn.maxRetries ?? 3;
-                    span?.setAttributes({
-                        ...Attribute.StepAttempt(attempt),
-                        ...Attribute.StepMaxRetries(maxRetries),
-                    });
-                    if (attempt >= maxRetries) {
-                        // Max retries reached
-                        const stackLines = getErrorStack(err).split('\n').slice(0, 4);
-                        console.error(`[Workflows] "${workflowRunId}" - Encountered \`Error\` while executing step "${stepName}" (attempt ${attempt}):\n  > ${stackLines.join('\n    > ')}\n\n  Max retries reached\n  Bubbling error to parent workflow`);
-                        const errorMessage = `Step "${stepName}" failed after max retries: ${String(err)}`;
-                        await world.events.create(workflowRunId, {
-                            eventType: 'step_failed',
-                            correlationId: stepId,
-                            eventData: {
-                                error: errorMessage,
-                                stack: getErrorStack(err),
-                                fatal: true,
-                            },
-                        });
-                        await world.steps.update(workflowRunId, stepId, {
-                            status: 'failed',
-                            error: errorMessage,
-                        });
-                        span?.setAttributes({
-                            ...Attribute.StepStatus('failed'),
-                            ...Attribute.StepRetryExhausted(true),
-                        });
-                    }
-                    else {
-                        // Not at max retries yet - log as a retryable error
-                        if (RetryableError.is(err)) {
-                            console.warn(`[Workflows] "${workflowRunId}" - Encountered \`RetryableError\` while executing step "${stepName}" (attempt ${attempt}):\n  > ${String(err.message)}\n\n  This step has failed but will be retried`);
-                        }
-                        else {
-                            const stackLines = getErrorStack(err).split('\n').slice(0, 4);
-                            console.error(`[Workflows] "${workflowRunId}" - Encountered \`Error\` while executing step "${stepName}" (attempt ${attempt}):\n  > ${stackLines.join('\n    > ')}\n\n  This step has failed but will be retried`);
-                        }
-                        await world.events.create(workflowRunId, {
-                            eventType: 'step_failed',
-                            correlationId: stepId,
-                            eventData: {
-                                error: String(err),
-                                stack: getErrorStack(err),
-                            },
-                        });
-                        await world.steps.update(workflowRunId, stepId, {
-                            status: 'pending', // TODO: Should be "retrying" once we have that status
-                            ...(RetryableError.is(err) && {
-                                retryAfter: err.retryAfter,
-                            }),
-                        });
-                        const timeoutSeconds = Math.max(1, RetryableError.is(err)
-                            ? Math.ceil((+err.retryAfter.getTime() - Date.now()) / 1000)
-                            : 1);
-                        span?.setAttributes({
-                            ...Attribute.StepRetryTimeoutSeconds(timeoutSeconds),
-                            ...Attribute.StepRetryWillRetry(true),
-                        });
-                        // It's a retryable error - so have the queue keep the message visible
-                        // so that it gets retried.
-                        return { timeoutSeconds };
-                    }
-                }
-            }
-            await world.queue(`__wkf_workflow_${workflowName}`, {
-                runId: workflowRunId,
-                traceCarrier: await serializeTraceCarrier(),
-            });
-        });
-    });
-});
 // this is a no-op placeholder as the client is
 // expecting this to be present but we aren't actually using it
 export function runStep() { }
-//# sourceMappingURL=runtime.js.map
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runtime.js","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"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"}