@workflow/core 5.0.0-beta.4 → 5.0.0-beta.6

package/dist/runtime/step-executor.js

@@ -0,0 +1,480 @@
+import { types } from 'node:util';
+import { waitUntil } from '@vercel/functions';
+import { EntityConflictError, FatalError, RetryableError, RunExpiredError, ThrottleError, TooEarlyError, WorkflowRuntimeError, } from '@workflow/errors';
+import { pluralize } from '@workflow/utils';
+import { SPEC_VERSION_CURRENT } from '@workflow/world';
+import { runtimeLogger, stepLogger } from '../logger.js';
+import { getStepFunction } from '../private.js';
+import { dehydrateStepError, dehydrateStepReturnValue, hydrateStepArguments, hydrateStepError, } from '../serialization.js';
+import { contextStorage } from '../step/context-storage.js';
+import * as Attribute from '../telemetry/semantic-conventions.js';
+import { trace } from '../telemetry.js';
+import { getErrorName, getErrorStack, normalizeUnknownError, } from '../types.js';
+import { getPortLazy } from './get-port-lazy.js';
+import { memoizeEncryptionKey } from './helpers.js';
+const DEFAULT_STEP_MAX_RETRIES = 3;
+/**
+ * Executes a single step: creates step_started event, hydrates input,
+ * runs the step function, creates step_completed/step_failed/step_retrying events.
+ *
+ * Does NOT queue workflow continuation messages — the caller decides what to do next.
+ * Used by both the V1 step handler and the V2 combined handler.
+ */
+export async function executeStep(params) {
+    const { world, workflowRunId, workflowName, workflowStartedAt, stepId, stepName, } = params;
+    const isVercel = process.env.VERCEL_URL !== undefined;
+    return trace(`STEP ${stepName}`, {}, async (span) => {
+        span?.setAttributes({
+            ...Attribute.StepName(stepName),
+            ...Attribute.WorkflowName(workflowName),
+            ...Attribute.WorkflowRunId(workflowRunId),
+            ...Attribute.StepId(stepId),
+        });
+        // Memoized accessor for the per-run encryption key. The first caller
+        // (input hydration on the success path, or one of the early-return
+        // dehydrateStepError paths if step_started fails) triggers the actual
+        // fetch / HKDF derivation; subsequent callers await the cached promise.
+        const getEncryptionKey = memoizeEncryptionKey(world, workflowRunId);
+        const stepFn = getStepFunction(stepName);
+        if (!stepFn || typeof stepFn !== 'function') {
+            // Step function not registered — fail the step immediately (not the run).
+            // This matches the V1 step handler pattern: create step_failed event so
+            // the workflow can handle it gracefully via try/catch in user code.
+            const errorMessage = `Step "${stepName}" is not registered in the current deployment. This usually indicates a build or bundling issue that caused the step to not be included in the deployment.`;
+            runtimeLogger.error('Step function not registered, failing step', {
+                workflowRunId,
+                stepName,
+                stepId,
+            });
+            try {
+                await world.events.create(workflowRunId, {
+                    eventType: 'step_failed',
+                    specVersion: SPEC_VERSION_CURRENT,
+                    correlationId: stepId,
+                    eventData: {
+                        error: await dehydrateStepError(new FatalError(errorMessage), workflowRunId, await getEncryptionKey()),
+                    },
+                });
+            }
+            catch (stepFailErr) {
+                if (EntityConflictError.is(stepFailErr)) {
+                    return { type: 'skipped' };
+                }
+                throw stepFailErr;
+            }
+            span?.setAttributes({
+                ...Attribute.StepStatus('failed'),
+                ...Attribute.StepFatalError(true),
+            });
+            return { type: 'failed' };
+        }
+        const maxRetries = stepFn.maxRetries ?? DEFAULT_STEP_MAX_RETRIES;
+        span?.setAttributes({
+            ...Attribute.StepMaxRetries(maxRetries),
+        });
+        // step_started validates state and returns the step entity
+        let step;
+        try {
+            const startResult = await world.events.create(workflowRunId, {
+                eventType: 'step_started',
+                specVersion: SPEC_VERSION_CURRENT,
+                correlationId: stepId,
+            });
+            if (!startResult.step) {
+                throw new WorkflowRuntimeError(`step_started event for "${stepId}" did not return step entity`);
+            }
+            step = startResult.step;
+        }
+        catch (err) {
+            if (ThrottleError.is(err)) {
+                const retryAfter = Math.max(1, typeof err.retryAfter === 'number' ? err.retryAfter : 1);
+                runtimeLogger.info('Throttled on step_started, deferring', {
+                    retryAfterSeconds: retryAfter,
+                });
+                return { type: 'throttled', timeoutSeconds: retryAfter };
+            }
+            if (RunExpiredError.is(err)) {
+                runtimeLogger.info(`Workflow run "${workflowRunId}" has already completed, skipping step "${stepId}": ${err.message}`);
+                return { type: 'gone' };
+            }
+            if (EntityConflictError.is(err)) {
+                runtimeLogger.debug('Step in terminal state, skipping', {
+                    stepName,
+                    stepId,
+                    workflowRunId,
+                    error: err.message,
+                });
+                span?.setAttributes({
+                    ...Attribute.StepSkipped(true),
+                    ...Attribute.StepSkipReason('completed'),
+                });
+                return { type: 'skipped' };
+            }
+            if (TooEarlyError.is(err)) {
+                const timeoutSeconds = Math.max(1, err.retryAfter ?? 1);
+                runtimeLogger.debug('Step retryAfter timestamp not yet reached', {
+                    stepName,
+                    stepId,
+                    timeoutSeconds,
+                });
+                return { type: 'retry', timeoutSeconds };
+            }
+            throw err;
+        }
+        runtimeLogger.debug('Step execution details', {
+            stepName,
+            stepId: step.stepId,
+            status: step.status,
+            attempt: step.attempt,
+        });
+        span?.setAttributes({
+            ...Attribute.StepStatus(step.status),
+        });
+        let result;
+        // Check max retries AFTER step_started (attempt was just incremented).
+        // Only enforce when the step has a previous error — this distinguishes
+        // actual retries (failed → retry) from concurrent starts (V2 inline
+        // execution loop can cause multiple handlers to step_started the same
+        // step simultaneously, inflating the attempt counter without any failure).
+        if (step.attempt > maxRetries + 1 && step.error) {
+            const retryCount = step.attempt - 1;
+            const errorMessage = `Step "${stepName}" exceeded max retries (${retryCount} ${pluralize('retry', 'retries', retryCount)})`;
+            stepLogger.error('Step exceeded max retries', {
+                workflowRunId,
+                stepName,
+                retryCount,
+            });
+            // Preserve the prior attempt's serialized error as the cause so the
+            // underlying failure is recoverable from `step.error.cause` after
+            // hydration, without forcing consumers to walk the step_retrying
+            // event history. Best-effort: if hydration of the prior `step.error`
+            // throws, fall back to a FatalError without cause.
+            const wrappedError = new FatalError(errorMessage);
+            if (step.error != null) {
+                try {
+                    wrappedError.cause = await hydrateStepError(step.error, workflowRunId, await getEncryptionKey());
+                }
+                catch {
+                    // Ignore — best-effort cause attachment.
+                }
+            }
+            try {
+                await world.events.create(workflowRunId, {
+                    eventType: 'step_failed',
+                    specVersion: SPEC_VERSION_CURRENT,
+                    correlationId: stepId,
+                    eventData: {
+                        error: await dehydrateStepError(wrappedError, workflowRunId, await getEncryptionKey()),
+                    },
+                });
+            }
+            catch (err) {
+                if (EntityConflictError.is(err)) {
+                    runtimeLogger.info('Tried failing step, but step has already finished.', {
+                        workflowRunId,
+                        stepId,
+                        stepName,
+                        message: err.message,
+                    });
+                    return { type: 'skipped' };
+                }
+                throw err;
+            }
+            span?.setAttributes({
+                ...Attribute.StepStatus('failed'),
+                ...Attribute.StepRetryExhausted(true),
+            });
+            return { type: 'failed' };
+        }
+        try {
+            const attempt = step.attempt;
+            if (!step.startedAt) {
+                throw new WorkflowRuntimeError(`Step "${stepId}" has no "startedAt" timestamp`);
+            }
+            const stepStartedAt = step.startedAt;
+            const ops = [];
+            // Use the provided encryption key when available, otherwise resolve
+            // through the memoized accessor declared at the top of this trace.
+            const encryptionKey = params.encryptionKey ?? (await getEncryptionKey());
+            const hydratedInput = await trace('step.hydrate', {}, async (hydrateSpan) => {
+                const startTime = Date.now();
+                const hydrated = await hydrateStepArguments(step.input, workflowRunId, encryptionKey, ops);
+                const durationMs = Date.now() - startTime;
+                hydrateSpan?.setAttributes({
+                    ...Attribute.StepArgumentsCount(hydrated.args.length),
+                    ...Attribute.QueueDeserializeTimeMs(durationMs),
+                });
+                return hydrated;
+            });
+            const args = hydratedInput.args;
+            const thisVal = hydratedInput.thisVal ?? null;
+            const port = isVercel ? undefined : await getPortLazy();
+            const executionStartTime = Date.now();
+            result = await trace('step.execute', {}, async () => {
+                return await contextStorage.run({
+                    stepMetadata: {
+                        stepName,
+                        stepId,
+                        stepStartedAt: new Date(+stepStartedAt),
+                        attempt,
+                    },
+                    workflowMetadata: {
+                        workflowName,
+                        workflowRunId,
+                        workflowStartedAt: new Date(+workflowStartedAt),
+                        url: isVercel
+                            ? `https://${process.env.VERCEL_URL}`
+                            : `http://localhost:${port ?? 3000}`,
+                        features: { encryption: !!encryptionKey },
+                    },
+                    ops,
+                    closureVars: hydratedInput.closureVars,
+                    encryptionKey,
+                }, () => stepFn.apply(thisVal, args));
+            });
+            const executionTimeMs = Date.now() - executionStartTime;
+            span?.setAttributes({
+                ...Attribute.QueueExecutionTimeMs(executionTimeMs),
+            });
+            result = await trace('step.dehydrate', {}, async (dehydrateSpan) => {
+                const startTime = Date.now();
+                const dehydrated = await dehydrateStepReturnValue(result, workflowRunId, encryptionKey, ops);
+                const durationMs = Date.now() - startTime;
+                dehydrateSpan?.setAttributes({
+                    ...Attribute.QueueSerializeTimeMs(durationMs),
+                    ...Attribute.StepResultType(typeof dehydrated),
+                });
+                return dehydrated;
+            });
+            // Flush pending ops (stream writes, etc.) with a short inline wait.
+            // Now that WorkflowServerWritableStream flushes synchronously on
+            // each write (not via setTimeout), the flushablePipe's pendingOps
+            // accurately reflects whether data has reached the server. Most ops
+            // settle within ~200ms (100ms lock-release polling + HTTP flush).
+            // If ops don't settle in 500ms (e.g., WritableStream kept open
+            // across steps), waitUntil handles the rest.
+            let opsSettled = true;
+            if (ops.length > 0) {
+                const opsPromise = Promise.all(ops).catch((err) => {
+                    const isAbortError = err?.name === 'AbortError' || err?.name === 'ResponseAborted';
+                    if (!isAbortError)
+                        throw err;
+                });
+                waitUntil(opsPromise);
+                opsSettled = await Promise.race([
+                    opsPromise.then(() => true),
+                    new Promise((r) => setTimeout(() => r(false), 500)),
+                ]);
+            }
+            // Create step_completed event
+            let stepCompleted409 = false;
+            await world.events
+                .create(workflowRunId, {
+                eventType: 'step_completed',
+                specVersion: SPEC_VERSION_CURRENT,
+                correlationId: stepId,
+                eventData: {
+                    result: result,
+                },
+            })
+                .catch((err) => {
+                if (EntityConflictError.is(err)) {
+                    runtimeLogger.info('Tried completing step, but step has already finished.', {
+                        workflowRunId,
+                        stepId,
+                        stepName,
+                        message: err.message,
+                    });
+                    stepCompleted409 = true;
+                    return;
+                }
+                throw err;
+            });
+            if (stepCompleted409) {
+                return { type: 'skipped' };
+            }
+            span?.setAttributes({
+                ...Attribute.StepStatus('completed'),
+                ...Attribute.StepResultType(typeof result),
+            });
+            if (ops.length > 0) {
+                stepLogger.debug('Step has pending ops', {
+                    workflowRunId,
+                    stepName,
+                    opsCount: ops.length,
+                });
+            }
+            // hasPendingOps signals the V2 handler to break the loop
+            // and queue a continuation so waitUntil can flush them.
+            return { type: 'completed', hasPendingOps: !opsSettled };
+        }
+        catch (err) {
+            const normalizedError = await normalizeUnknownError(err);
+            const normalizedStack = normalizedError.stack || getErrorStack(err) || '';
+            if (err instanceof Error) {
+                span?.recordException?.(err);
+            }
+            const isFatal = FatalError.is(err);
+            span?.setAttributes({
+                ...Attribute.StepErrorName(getErrorName(err)),
+                ...Attribute.StepErrorMessage(normalizedError.message),
+                ...Attribute.ErrorType(getErrorName(err)),
+                ...Attribute.ErrorCategory(isFatal ? 'fatal' : RetryableError.is(err) ? 'retryable' : 'transient'),
+                ...Attribute.ErrorRetryable(!isFatal),
+            });
+            if (RunExpiredError.is(err)) {
+                stepLogger.info('Workflow run already completed, skipping step', {
+                    workflowRunId,
+                    stepId,
+                    message: err.message,
+                });
+                return { type: 'gone' };
+            }
+            if (isFatal) {
+                stepLogger.error('Encountered FatalError while executing step, bubbling up to parent workflow', { workflowRunId, stepName, errorStack: normalizedStack });
+                // Apply the normalized stack to the thrown value so the serialized
+                // error preserves it for consumers. `types.isNativeError()` works
+                // across VM realms (a workflow-thrown error is an instance of the
+                // VM's Error class, not the host's).
+                if (types.isNativeError(err) && normalizedStack) {
+                    err.stack = normalizedStack;
+                }
+                try {
+                    await world.events.create(workflowRunId, {
+                        eventType: 'step_failed',
+                        specVersion: SPEC_VERSION_CURRENT,
+                        correlationId: stepId,
+                        eventData: {
+                            error: await dehydrateStepError(err, workflowRunId, await getEncryptionKey()),
+                        },
+                    });
+                }
+                catch (stepFailErr) {
+                    if (EntityConflictError.is(stepFailErr)) {
+                        runtimeLogger.info('Tried failing step, but step has already finished.', {
+                            workflowRunId,
+                            stepId,
+                            stepName,
+                            message: stepFailErr.message,
+                        });
+                        return { type: 'skipped' };
+                    }
+                    throw stepFailErr;
+                }
+                span?.setAttributes({
+                    ...Attribute.StepStatus('failed'),
+                    ...Attribute.StepFatalError(true),
+                });
+                return { type: 'failed' };
+            }
+            // Non-fatal error: check if retries remaining
+            const currentAttempt = step.attempt;
+            span?.setAttributes({
+                ...Attribute.StepAttempt(currentAttempt),
+                ...Attribute.StepMaxRetries(maxRetries),
+            });
+            if (currentAttempt >= maxRetries + 1) {
+                // Max retries reached
+                const retryCount = step.attempt - 1;
+                stepLogger.error('Max retries reached, bubbling error to parent workflow', {
+                    workflowRunId,
+                    stepName,
+                    attempt: step.attempt,
+                    retryCount,
+                    errorStack: normalizedStack,
+                });
+                const errorMessage = `Step "${stepName}" failed after ${maxRetries} ${pluralize('retry', 'retries', maxRetries)}: ${normalizedError.message}`;
+                // Wrap the original thrown value as `cause` on a fresh FatalError
+                // so the wrapping message + retry-count framing is the user-facing
+                // error while the original failure remains recoverable from
+                // `err.cause` after hydration.
+                const wrappedError = new FatalError(errorMessage);
+                wrappedError.cause = err;
+                if (normalizedStack)
+                    wrappedError.stack = normalizedStack;
+                try {
+                    await world.events.create(workflowRunId, {
+                        eventType: 'step_failed',
+                        specVersion: SPEC_VERSION_CURRENT,
+                        correlationId: stepId,
+                        eventData: {
+                            error: await dehydrateStepError(wrappedError, workflowRunId, await getEncryptionKey()),
+                        },
+                    });
+                }
+                catch (stepFailErr) {
+                    if (EntityConflictError.is(stepFailErr)) {
+                        runtimeLogger.info('Tried failing step, but step has already finished.', {
+                            workflowRunId,
+                            stepId,
+                            stepName,
+                            message: stepFailErr.message,
+                        });
+                        return { type: 'skipped' };
+                    }
+                    throw stepFailErr;
+                }
+                span?.setAttributes({
+                    ...Attribute.StepStatus('failed'),
+                    ...Attribute.StepRetryExhausted(true),
+                });
+                return { type: 'failed' };
+            }
+            // Retries remaining
+            if (RetryableError.is(err)) {
+                stepLogger.info('Encountered RetryableError, step will be retried', {
+                    workflowRunId,
+                    stepName,
+                    attempt: currentAttempt,
+                    message: err.message,
+                });
+            }
+            else {
+                stepLogger.info('Encountered Error, step will be retried', {
+                    workflowRunId,
+                    stepName,
+                    attempt: currentAttempt,
+                    errorStack: normalizedStack,
+                });
+            }
+            // Apply the normalized stack to the thrown value so it survives
+            // serialization. See the FatalError site above for why we use
+            // `types.isNativeError` instead of `err instanceof Error`.
+            if (types.isNativeError(err) && normalizedStack) {
+                err.stack = normalizedStack;
+            }
+            try {
+                await world.events.create(workflowRunId, {
+                    eventType: 'step_retrying',
+                    specVersion: SPEC_VERSION_CURRENT,
+                    correlationId: stepId,
+                    eventData: {
+                        error: await dehydrateStepError(err, workflowRunId, await getEncryptionKey()),
+                        ...(RetryableError.is(err) && { retryAfter: err.retryAfter }),
+                    },
+                });
+            }
+            catch (stepRetryErr) {
+                if (EntityConflictError.is(stepRetryErr)) {
+                    runtimeLogger.info('Tried retrying step, but step has already finished.', {
+                        workflowRunId,
+                        stepId,
+                        stepName,
+                        message: stepRetryErr.message,
+                    });
+                    return { type: 'skipped' };
+                }
+                throw stepRetryErr;
+            }
+            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),
+            });
+            return { type: 'retry', timeoutSeconds };
+        }
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"step-executor.js","sourceRoot":"","sources":["../../src/runtime/step-executor.ts"],"names":[],"mappings":"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","sourcesContent":["import { types } from 'node:util';\nimport { waitUntil } from '@vercel/functions';\nimport {\n  EntityConflictError,\n  FatalError,\n  RetryableError,\n  RunExpiredError,\n  ThrottleError,\n  TooEarlyError,\n  WorkflowRuntimeError,\n} from '@workflow/errors';\nimport { pluralize } from '@workflow/utils';\nimport type { World } from '@workflow/world';\nimport { SPEC_VERSION_CURRENT } from '@workflow/world';\nimport type { CryptoKey } from '../encryption.js';\nimport { runtimeLogger, stepLogger } from '../logger.js';\nimport { getStepFunction } from '../private.js';\nimport {\n  dehydrateStepError,\n  dehydrateStepReturnValue,\n  hydrateStepArguments,\n  hydrateStepError,\n} from '../serialization.js';\nimport { contextStorage } from '../step/context-storage.js';\nimport * as Attribute from '../telemetry/semantic-conventions.js';\nimport { trace } from '../telemetry.js';\nimport {\n  getErrorName,\n  getErrorStack,\n  normalizeUnknownError,\n} from '../types.js';\nimport { getPortLazy } from './get-port-lazy.js';\nimport { memoizeEncryptionKey } from './helpers.js';\n\nconst DEFAULT_STEP_MAX_RETRIES = 3;\n\nexport interface StepExecutorParams {\n  world: World;\n  workflowRunId: string;\n  workflowName: string;\n  workflowStartedAt: number;\n  stepId: string;\n  stepName: string;\n  encryptionKey?: CryptoKey;\n}\n\n/**\n * Result of a step execution attempt. The caller decides what to do\n * based on the result type (e.g., queue workflow continuation, replay inline, etc.).\n */\nexport type StepExecutionResult =\n  | { type: 'completed'; hasPendingOps?: boolean }\n  | { type: 'failed' }\n  | { type: 'retry'; timeoutSeconds: number }\n  | { type: 'skipped' }\n  | { type: 'gone' }\n  | { type: 'throttled'; timeoutSeconds: number };\n\n/**\n * Executes a single step: creates step_started event, hydrates input,\n * runs the step function, creates step_completed/step_failed/step_retrying events.\n *\n * Does NOT queue workflow continuation messages — the caller decides what to do next.\n * Used by both the V1 step handler and the V2 combined handler.\n */\nexport async function executeStep(\n  params: StepExecutorParams\n): Promise<StepExecutionResult> {\n  const {\n    world,\n    workflowRunId,\n    workflowName,\n    workflowStartedAt,\n    stepId,\n    stepName,\n  } = params;\n  const isVercel = process.env.VERCEL_URL !== undefined;\n\n  return trace(`STEP ${stepName}`, {}, async (span) => {\n    span?.setAttributes({\n      ...Attribute.StepName(stepName),\n      ...Attribute.WorkflowName(workflowName),\n      ...Attribute.WorkflowRunId(workflowRunId),\n      ...Attribute.StepId(stepId),\n    });\n\n    // Memoized accessor for the per-run encryption key. The first caller\n    // (input hydration on the success path, or one of the early-return\n    // dehydrateStepError paths if step_started fails) triggers the actual\n    // fetch / HKDF derivation; subsequent callers await the cached promise.\n    const getEncryptionKey = memoizeEncryptionKey(world, workflowRunId);\n\n    const stepFn = getStepFunction(stepName);\n    if (!stepFn || typeof stepFn !== 'function') {\n      // Step function not registered — fail the step immediately (not the run).\n      // This matches the V1 step handler pattern: create step_failed event so\n      // the workflow can handle it gracefully via try/catch in user code.\n      const errorMessage = `Step \"${stepName}\" is not registered in the current deployment. This usually indicates a build or bundling issue that caused the step to not be included in the deployment.`;\n      runtimeLogger.error('Step function not registered, failing step', {\n        workflowRunId,\n        stepName,\n        stepId,\n      });\n      try {\n        await world.events.create(workflowRunId, {\n          eventType: 'step_failed',\n          specVersion: SPEC_VERSION_CURRENT,\n          correlationId: stepId,\n          eventData: {\n            error: await dehydrateStepError(\n              new FatalError(errorMessage),\n              workflowRunId,\n              await getEncryptionKey()\n            ),\n          },\n        });\n      } catch (stepFailErr) {\n        if (EntityConflictError.is(stepFailErr)) {\n          return { type: 'skipped' };\n        }\n        throw stepFailErr;\n      }\n      span?.setAttributes({\n        ...Attribute.StepStatus('failed'),\n        ...Attribute.StepFatalError(true),\n      });\n      return { type: 'failed' };\n    }\n\n    const maxRetries = stepFn.maxRetries ?? DEFAULT_STEP_MAX_RETRIES;\n\n    span?.setAttributes({\n      ...Attribute.StepMaxRetries(maxRetries),\n    });\n\n    // step_started validates state and returns the step entity\n    let step;\n    try {\n      const startResult = await world.events.create(workflowRunId, {\n        eventType: 'step_started',\n        specVersion: SPEC_VERSION_CURRENT,\n        correlationId: stepId,\n      });\n\n      if (!startResult.step) {\n        throw new WorkflowRuntimeError(\n          `step_started event for \"${stepId}\" did not return step entity`\n        );\n      }\n      step = startResult.step;\n    } catch (err) {\n      if (ThrottleError.is(err)) {\n        const retryAfter = Math.max(\n          1,\n          typeof err.retryAfter === 'number' ? err.retryAfter : 1\n        );\n        runtimeLogger.info('Throttled on step_started, deferring', {\n          retryAfterSeconds: retryAfter,\n        });\n        return { type: 'throttled', timeoutSeconds: retryAfter };\n      }\n      if (RunExpiredError.is(err)) {\n        runtimeLogger.info(\n          `Workflow run \"${workflowRunId}\" has already completed, skipping step \"${stepId}\": ${err.message}`\n        );\n        return { type: 'gone' };\n      }\n      if (EntityConflictError.is(err)) {\n        runtimeLogger.debug('Step in terminal state, skipping', {\n          stepName,\n          stepId,\n          workflowRunId,\n          error: err.message,\n        });\n        span?.setAttributes({\n          ...Attribute.StepSkipped(true),\n          ...Attribute.StepSkipReason('completed'),\n        });\n        return { type: 'skipped' };\n      }\n      if (TooEarlyError.is(err)) {\n        const timeoutSeconds = Math.max(1, err.retryAfter ?? 1);\n        runtimeLogger.debug('Step retryAfter timestamp not yet reached', {\n          stepName,\n          stepId,\n          timeoutSeconds,\n        });\n        return { type: 'retry', timeoutSeconds };\n      }\n      throw err;\n    }\n\n    runtimeLogger.debug('Step execution details', {\n      stepName,\n      stepId: step.stepId,\n      status: step.status,\n      attempt: step.attempt,\n    });\n\n    span?.setAttributes({\n      ...Attribute.StepStatus(step.status),\n    });\n\n    let result: unknown;\n\n    // Check max retries AFTER step_started (attempt was just incremented).\n    // Only enforce when the step has a previous error — this distinguishes\n    // actual retries (failed → retry) from concurrent starts (V2 inline\n    // execution loop can cause multiple handlers to step_started the same\n    // step simultaneously, inflating the attempt counter without any failure).\n    if (step.attempt > maxRetries + 1 && step.error) {\n      const retryCount = step.attempt - 1;\n      const errorMessage = `Step \"${stepName}\" exceeded max retries (${retryCount} ${pluralize('retry', 'retries', retryCount)})`;\n      stepLogger.error('Step exceeded max retries', {\n        workflowRunId,\n        stepName,\n        retryCount,\n      });\n      // Preserve the prior attempt's serialized error as the cause so the\n      // underlying failure is recoverable from `step.error.cause` after\n      // hydration, without forcing consumers to walk the step_retrying\n      // event history. Best-effort: if hydration of the prior `step.error`\n      // throws, fall back to a FatalError without cause.\n      const wrappedError = new FatalError(errorMessage);\n      if (step.error != null) {\n        try {\n          (wrappedError as Error).cause = await hydrateStepError(\n            step.error,\n            workflowRunId,\n            await getEncryptionKey()\n          );\n        } catch {\n          // Ignore — best-effort cause attachment.\n        }\n      }\n      try {\n        await world.events.create(workflowRunId, {\n          eventType: 'step_failed',\n          specVersion: SPEC_VERSION_CURRENT,\n          correlationId: stepId,\n          eventData: {\n            error: await dehydrateStepError(\n              wrappedError,\n              workflowRunId,\n              await getEncryptionKey()\n            ),\n          },\n        });\n      } catch (err) {\n        if (EntityConflictError.is(err)) {\n          runtimeLogger.info(\n            'Tried failing step, but step has already finished.',\n            {\n              workflowRunId,\n              stepId,\n              stepName,\n              message: err.message,\n            }\n          );\n          return { type: 'skipped' };\n        }\n        throw err;\n      }\n      span?.setAttributes({\n        ...Attribute.StepStatus('failed'),\n        ...Attribute.StepRetryExhausted(true),\n      });\n      return { type: 'failed' };\n    }\n\n    try {\n      const attempt = step.attempt;\n\n      if (!step.startedAt) {\n        throw new WorkflowRuntimeError(\n          `Step \"${stepId}\" has no \"startedAt\" timestamp`\n        );\n      }\n      const stepStartedAt = step.startedAt;\n      const ops: Promise<void>[] = [];\n      // Use the provided encryption key when available, otherwise resolve\n      // through the memoized accessor declared at the top of this trace.\n      const encryptionKey = params.encryptionKey ?? (await getEncryptionKey());\n      const hydratedInput = await trace(\n        'step.hydrate',\n        {},\n        async (hydrateSpan) => {\n          const startTime = Date.now();\n          const hydrated = await hydrateStepArguments(\n            step.input,\n            workflowRunId,\n            encryptionKey,\n            ops\n          );\n          const durationMs = Date.now() - startTime;\n          hydrateSpan?.setAttributes({\n            ...Attribute.StepArgumentsCount(hydrated.args.length),\n            ...Attribute.QueueDeserializeTimeMs(durationMs),\n          });\n          return hydrated;\n        }\n      );\n\n      const args = hydratedInput.args;\n      const thisVal = hydratedInput.thisVal ?? null;\n      const port = isVercel ? undefined : await getPortLazy();\n\n      const executionStartTime = Date.now();\n      result = await trace('step.execute', {}, async () => {\n        return await contextStorage.run(\n          {\n            stepMetadata: {\n              stepName,\n              stepId,\n              stepStartedAt: new Date(+stepStartedAt),\n              attempt,\n            },\n            workflowMetadata: {\n              workflowName,\n              workflowRunId,\n              workflowStartedAt: new Date(+workflowStartedAt),\n              url: isVercel\n                ? `https://${process.env.VERCEL_URL}`\n                : `http://localhost:${port ?? 3000}`,\n              features: { encryption: !!encryptionKey },\n            },\n            ops,\n            closureVars: hydratedInput.closureVars,\n            encryptionKey,\n          },\n          () => stepFn.apply(thisVal, args)\n        );\n      });\n      const executionTimeMs = Date.now() - executionStartTime;\n\n      span?.setAttributes({\n        ...Attribute.QueueExecutionTimeMs(executionTimeMs),\n      });\n\n      result = await trace('step.dehydrate', {}, async (dehydrateSpan) => {\n        const startTime = Date.now();\n        const dehydrated = await dehydrateStepReturnValue(\n          result,\n          workflowRunId,\n          encryptionKey,\n          ops\n        );\n        const durationMs = Date.now() - startTime;\n        dehydrateSpan?.setAttributes({\n          ...Attribute.QueueSerializeTimeMs(durationMs),\n          ...Attribute.StepResultType(typeof dehydrated),\n        });\n        return dehydrated;\n      });\n\n      // Flush pending ops (stream writes, etc.) with a short inline wait.\n      // Now that WorkflowServerWritableStream flushes synchronously on\n      // each write (not via setTimeout), the flushablePipe's pendingOps\n      // accurately reflects whether data has reached the server. Most ops\n      // settle within ~200ms (100ms lock-release polling + HTTP flush).\n      // If ops don't settle in 500ms (e.g., WritableStream kept open\n      // across steps), waitUntil handles the rest.\n      let opsSettled = true;\n      if (ops.length > 0) {\n        const opsPromise = Promise.all(ops).catch((err) => {\n          const isAbortError =\n            err?.name === 'AbortError' || err?.name === 'ResponseAborted';\n          if (!isAbortError) throw err;\n        });\n        waitUntil(opsPromise);\n        opsSettled = await Promise.race([\n          opsPromise.then(() => true as const),\n          new Promise<false>((r) => setTimeout(() => r(false), 500)),\n        ]);\n      }\n\n      // Create step_completed event\n      let stepCompleted409 = false;\n      await world.events\n        .create(workflowRunId, {\n          eventType: 'step_completed',\n          specVersion: SPEC_VERSION_CURRENT,\n          correlationId: stepId,\n          eventData: {\n            result: result as Uint8Array,\n          },\n        })\n        .catch((err) => {\n          if (EntityConflictError.is(err)) {\n            runtimeLogger.info(\n              'Tried completing step, but step has already finished.',\n              {\n                workflowRunId,\n                stepId,\n                stepName,\n                message: err.message,\n              }\n            );\n            stepCompleted409 = true;\n            return;\n          }\n          throw err;\n        });\n\n      if (stepCompleted409) {\n        return { type: 'skipped' };\n      }\n\n      span?.setAttributes({\n        ...Attribute.StepStatus('completed'),\n        ...Attribute.StepResultType(typeof result),\n      });\n\n      if (ops.length > 0) {\n        stepLogger.debug('Step has pending ops', {\n          workflowRunId,\n          stepName,\n          opsCount: ops.length,\n        });\n      }\n      // hasPendingOps signals the V2 handler to break the loop\n      // and queue a continuation so waitUntil can flush them.\n      return { type: 'completed', hasPendingOps: !opsSettled };\n    } catch (err: unknown) {\n      const normalizedError = await normalizeUnknownError(err);\n      const normalizedStack = normalizedError.stack || getErrorStack(err) || '';\n\n      if (err instanceof Error) {\n        span?.recordException?.(err);\n      }\n\n      const isFatal = FatalError.is(err);\n\n      span?.setAttributes({\n        ...Attribute.StepErrorName(getErrorName(err)),\n        ...Attribute.StepErrorMessage(normalizedError.message),\n        ...Attribute.ErrorType(getErrorName(err)),\n        ...Attribute.ErrorCategory(\n          isFatal ? 'fatal' : RetryableError.is(err) ? 'retryable' : 'transient'\n        ),\n        ...Attribute.ErrorRetryable(!isFatal),\n      });\n\n      if (RunExpiredError.is(err)) {\n        stepLogger.info('Workflow run already completed, skipping step', {\n          workflowRunId,\n          stepId,\n          message: err.message,\n        });\n        return { type: 'gone' };\n      }\n\n      if (isFatal) {\n        stepLogger.error(\n          'Encountered FatalError while executing step, bubbling up to parent workflow',\n          { workflowRunId, stepName, errorStack: normalizedStack }\n        );\n        // Apply the normalized stack to the thrown value so the serialized\n        // error preserves it for consumers. `types.isNativeError()` works\n        // across VM realms (a workflow-thrown error is an instance of the\n        // VM's Error class, not the host's).\n        if (types.isNativeError(err) && normalizedStack) {\n          (err as Error).stack = normalizedStack;\n        }\n        try {\n          await world.events.create(workflowRunId, {\n            eventType: 'step_failed',\n            specVersion: SPEC_VERSION_CURRENT,\n            correlationId: stepId,\n            eventData: {\n              error: await dehydrateStepError(\n                err,\n                workflowRunId,\n                await getEncryptionKey()\n              ),\n            },\n          });\n        } catch (stepFailErr) {\n          if (EntityConflictError.is(stepFailErr)) {\n            runtimeLogger.info(\n              'Tried failing step, but step has already finished.',\n              {\n                workflowRunId,\n                stepId,\n                stepName,\n                message: stepFailErr.message,\n              }\n            );\n            return { type: 'skipped' };\n          }\n          throw stepFailErr;\n        }\n        span?.setAttributes({\n          ...Attribute.StepStatus('failed'),\n          ...Attribute.StepFatalError(true),\n        });\n        return { type: 'failed' };\n      }\n\n      // Non-fatal error: check if retries remaining\n      const currentAttempt = step.attempt;\n\n      span?.setAttributes({\n        ...Attribute.StepAttempt(currentAttempt),\n        ...Attribute.StepMaxRetries(maxRetries),\n      });\n\n      if (currentAttempt >= maxRetries + 1) {\n        // Max retries reached\n        const retryCount = step.attempt - 1;\n        stepLogger.error(\n          'Max retries reached, bubbling error to parent workflow',\n          {\n            workflowRunId,\n            stepName,\n            attempt: step.attempt,\n            retryCount,\n            errorStack: normalizedStack,\n          }\n        );\n        const errorMessage = `Step \"${stepName}\" failed after ${maxRetries} ${pluralize('retry', 'retries', maxRetries)}: ${normalizedError.message}`;\n        // Wrap the original thrown value as `cause` on a fresh FatalError\n        // so the wrapping message + retry-count framing is the user-facing\n        // error while the original failure remains recoverable from\n        // `err.cause` after hydration.\n        const wrappedError = new FatalError(errorMessage);\n        (wrappedError as Error).cause = err;\n        if (normalizedStack) wrappedError.stack = normalizedStack;\n        try {\n          await world.events.create(workflowRunId, {\n            eventType: 'step_failed',\n            specVersion: SPEC_VERSION_CURRENT,\n            correlationId: stepId,\n            eventData: {\n              error: await dehydrateStepError(\n                wrappedError,\n                workflowRunId,\n                await getEncryptionKey()\n              ),\n            },\n          });\n        } catch (stepFailErr) {\n          if (EntityConflictError.is(stepFailErr)) {\n            runtimeLogger.info(\n              'Tried failing step, but step has already finished.',\n              {\n                workflowRunId,\n                stepId,\n                stepName,\n                message: stepFailErr.message,\n              }\n            );\n            return { type: 'skipped' };\n          }\n          throw stepFailErr;\n        }\n        span?.setAttributes({\n          ...Attribute.StepStatus('failed'),\n          ...Attribute.StepRetryExhausted(true),\n        });\n        return { type: 'failed' };\n      }\n\n      // Retries remaining\n      if (RetryableError.is(err)) {\n        stepLogger.info('Encountered RetryableError, step will be retried', {\n          workflowRunId,\n          stepName,\n          attempt: currentAttempt,\n          message: err.message,\n        });\n      } else {\n        stepLogger.info('Encountered Error, step will be retried', {\n          workflowRunId,\n          stepName,\n          attempt: currentAttempt,\n          errorStack: normalizedStack,\n        });\n      }\n\n      // Apply the normalized stack to the thrown value so it survives\n      // serialization. See the FatalError site above for why we use\n      // `types.isNativeError` instead of `err instanceof Error`.\n      if (types.isNativeError(err) && normalizedStack) {\n        (err as Error).stack = normalizedStack;\n      }\n      try {\n        await world.events.create(workflowRunId, {\n          eventType: 'step_retrying',\n          specVersion: SPEC_VERSION_CURRENT,\n          correlationId: stepId,\n          eventData: {\n            error: await dehydrateStepError(\n              err,\n              workflowRunId,\n              await getEncryptionKey()\n            ),\n            ...(RetryableError.is(err) && { retryAfter: err.retryAfter }),\n          },\n        });\n      } catch (stepRetryErr) {\n        if (EntityConflictError.is(stepRetryErr)) {\n          runtimeLogger.info(\n            'Tried retrying step, but step has already finished.',\n            {\n              workflowRunId,\n              stepId,\n              stepName,\n              message: stepRetryErr.message,\n            }\n          );\n          return { type: 'skipped' };\n        }\n        throw stepRetryErr;\n      }\n\n      const timeoutSeconds = Math.max(\n        1,\n        RetryableError.is(err)\n          ? Math.ceil((+err.retryAfter.getTime() - Date.now()) / 1000)\n          : 1\n      );\n\n      span?.setAttributes({\n        ...Attribute.StepRetryTimeoutSeconds(timeoutSeconds),\n        ...Attribute.StepRetryWillRetry(true),\n      });\n\n      return { type: 'retry', timeoutSeconds };\n    }\n  });\n}\n"]}

package/dist/runtime/step-handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"step-handler.d.ts","sourceRoot":"","sources":["../../src/runtime/step-handler.ts"],"names":[],"mappings":"AAq3BA,eAAO,MAAM,cAAc,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAM3D,CAAC"}
+{"version":3,"file":"step-handler.d.ts","sourceRoot":"","sources":["../../src/runtime/step-handler.ts"],"names":[],"mappings":"AAygCA,eAAO,MAAM,cAAc,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAM3D,CAAC"}