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

package/dist/runtime/step-handler.js

@@ -0,0 +1,337 @@
+import { waitUntil } from '@vercel/functions';
+import { FatalError, RetryableError, WorkflowAPIError, WorkflowRuntimeError, } from '@workflow/errors';
+import { pluralize } from '@workflow/utils';
+import { getPort } from '@workflow/utils/get-port';
+import { SPEC_VERSION_CURRENT, StepInvokePayloadSchema } from '@workflow/world';
+import { runtimeLogger } from '../logger.js';
+import { getStepFunction } from '../private.js';
+import { dehydrateStepReturnValue, hydrateStepArguments, } from '../serialization.js';
+import { contextStorage } from '../step/context-storage.js';
+import * as Attribute from '../telemetry/semantic-conventions.js';
+import { getSpanKind, linkToCurrentContext, serializeTraceCarrier, trace, withTraceContext, } from '../telemetry.js';
+import { getErrorName, getErrorStack } from '../types.js';
+import { getQueueOverhead, handleHealthCheckMessage, parseHealthCheckPayload, queueMessage, withHealthCheck, } from './helpers.js';
+import { getWorld, getWorldHandlers } from './world.js';
+const DEFAULT_STEP_MAX_RETRIES = 3;
+const stepHandler = getWorldHandlers().createQueueHandler('__wkf_step_', 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, 'step');
+        return;
+    }
+    const { workflowName, workflowRunId, workflowStartedAt, stepId, traceCarrier: traceContext, requestedAt, } = StepInvokePayloadSchema.parse(message_);
+    const spanLinks = await linkToCurrentContext();
+    // 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();
+        // Get the port early to avoid async operations during step execution
+        const port = await getPort();
+        return trace(`STEP ${stepName}`, { kind: await getSpanKind('CONSUMER'), links: spanLinks }, async (span) => {
+            span?.setAttributes({
+                ...Attribute.StepName(stepName),
+                ...Attribute.StepAttempt(metadata.attempt),
+                ...Attribute.QueueName(metadata.queueName),
+                ...Attribute.QueueMessageId(metadata.messageId),
+                ...getQueueOverhead({ requestedAt }),
+            });
+            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})`);
+            }
+            const maxRetries = stepFn.maxRetries ?? DEFAULT_STEP_MAX_RETRIES;
+            span?.setAttributes({
+                ...Attribute.WorkflowName(workflowName),
+                ...Attribute.WorkflowRunId(workflowRunId),
+                ...Attribute.StepId(stepId),
+                ...Attribute.StepMaxRetries(maxRetries),
+                ...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;
+            // Check max retries FIRST before any state changes.
+            // step.attempt tracks how many times step_started has been called.
+            // If step.attempt >= maxRetries, we've already tried maxRetries times.
+            // This handles edge cases where the step handler is invoked after max retries have been exceeded
+            // (e.g., when the step repeatedly times out or fails before reaching the catch handler).
+            // Without this check, the step would retry forever.
+            // Note: maxRetries is the number of RETRIES after the first attempt, so total attempts = maxRetries + 1
+            // Use > here (not >=) because this guards against re-invocation AFTER all attempts are used.
+            // The post-failure check uses >= to decide whether to retry after a failure.
+            if (step.attempt > maxRetries + 1) {
+                const retryCount = step.attempt - 1;
+                const errorMessage = `Step "${stepName}" exceeded max retries (${retryCount} ${pluralize('retry', 'retries', retryCount)})`;
+                console.error(`[Workflows] "${workflowRunId}" - ${errorMessage}`);
+                // Fail the step via event (event-sourced architecture)
+                await world.events.create(workflowRunId, {
+                    eventType: 'step_failed',
+                    specVersion: SPEC_VERSION_CURRENT,
+                    correlationId: stepId,
+                    eventData: {
+                        error: errorMessage,
+                        stack: step.error?.stack,
+                    },
+                });
+                span?.setAttributes({
+                    ...Attribute.StepStatus('failed'),
+                    ...Attribute.StepRetryExhausted(true),
+                });
+                // Re-invoke the workflow to handle the failed step
+                await queueMessage(world, `__wkf_workflow_${workflowName}`, {
+                    runId: workflowRunId,
+                    traceCarrier: await serializeTraceCarrier(),
+                    requestedAt: new Date(),
+                });
+                return;
+            }
+            try {
+                if (!['pending', 'running'].includes(step.status)) {
+                    // We should only be running the step if it's either
+                    // a) pending - initial state, or state set on re-try
+                    // b) running - if a step fails mid-execution, like a function timeout
+                    // otherwise, the step has been invoked erroneously
+                    console.error(`[Workflows] "${workflowRunId}" - Step invoked erroneously, expected status "pending" or "running", got "${step.status}" instead, skipping execution`);
+                    span?.setAttributes({
+                        ...Attribute.StepSkipped(true),
+                        ...Attribute.StepSkipReason(step.status),
+                    });
+                    // There's a chance that a step terminates correctly, but the underlying process
+                    // fails or gets killed before the stepEntrypoint has a chance to re-enqueue the run.
+                    // The queue lease expires and stepEntrypoint again, which leads us here, so
+                    // we optimistically re-enqueue the workflow if the step is in a terminal state,
+                    // under the assumption that this edge case happened.
+                    // Until we move to atomic entity/event updates (World V2), there _could_ be an edge case
+                    // where the we execute this code based on the `step` entity status, but the runtime
+                    // failed to create the `step_completed` event (due to failing between step and event update),
+                    // in which case, this might lead to an infinite loop.
+                    // https://vercel.slack.com/archives/C09125LC4AX/p1765313809066679
+                    const isTerminalStep = [
+                        'completed',
+                        'failed',
+                        'cancelled',
+                    ].includes(step.status);
+                    if (isTerminalStep) {
+                        await queueMessage(world, `__wkf_workflow_${workflowName}`, {
+                            runId: workflowRunId,
+                            traceCarrier: await serializeTraceCarrier(),
+                            requestedAt: new Date(),
+                        });
+                    }
+                    return;
+                }
+                // Start the step via event (event-sourced architecture)
+                // step_started increments the attempt counter in the World implementation
+                const startResult = await world.events.create(workflowRunId, {
+                    eventType: 'step_started',
+                    specVersion: SPEC_VERSION_CURRENT,
+                    correlationId: stepId,
+                });
+                // Use the step entity from the event response (no extra get call needed)
+                if (!startResult.step) {
+                    throw new WorkflowRuntimeError(`step_started event for "${stepId}" did not return step entity`);
+                }
+                step = startResult.step;
+                // step.attempt is now the current attempt number (after increment)
+                const attempt = step.attempt;
+                if (!step.startedAt) {
+                    throw new WorkflowRuntimeError(`Step "${stepId}" has no "startedAt" timestamp`);
+                }
+                // Hydrate the step input arguments, closure variables, and thisVal
+                const ops = [];
+                const hydratedInput = hydrateStepArguments(step.input, ops, workflowRunId);
+                const args = hydratedInput.args;
+                const thisVal = hydratedInput.thisVal ?? null;
+                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 + local worlds.
+                        url: process.env.VERCEL_URL
+                            ? `https://${process.env.VERCEL_URL}`
+                            : `http://localhost:${port ?? 3000}`,
+                    },
+                    ops,
+                    closureVars: hydratedInput.closureVars,
+                }, () => stepFn.apply(thisVal, args));
+                // NOTE: None of the code from this point is guaranteed to run
+                // Since the step might fail or cause a function timeout and the process might be SIGKILL'd
+                // The workflow runtime must be resilient to the below code not executing on a failed step
+                result = dehydrateStepReturnValue(result, ops, workflowRunId);
+                waitUntil(Promise.all(ops).catch((err) => {
+                    // Ignore expected client disconnect errors (e.g., browser refresh during streaming)
+                    const isAbortError = err?.name === 'AbortError' || err?.name === 'ResponseAborted';
+                    if (!isAbortError)
+                        throw err;
+                }));
+                // Complete the step via event (event-sourced architecture)
+                // The event creation atomically updates the step entity
+                // result was dehydrated above by dehydrateStepReturnValue, which returns Uint8Array
+                await world.events.create(workflowRunId, {
+                    eventType: 'step_completed',
+                    specVersion: SPEC_VERSION_CURRENT,
+                    correlationId: stepId,
+                    eventData: {
+                        result: 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 errorStack = getErrorStack(err);
+                    const stackLines = errorStack.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`);
+                    // Fail the step via event (event-sourced architecture)
+                    await world.events.create(workflowRunId, {
+                        eventType: 'step_failed',
+                        specVersion: SPEC_VERSION_CURRENT,
+                        correlationId: stepId,
+                        eventData: {
+                            error: String(err),
+                            stack: errorStack,
+                        },
+                    });
+                    span?.setAttributes({
+                        ...Attribute.StepStatus('failed'),
+                        ...Attribute.StepFatalError(true),
+                    });
+                }
+                else {
+                    const maxRetries = stepFn.maxRetries ?? DEFAULT_STEP_MAX_RETRIES;
+                    // step.attempt was incremented by step_started, use it here
+                    const currentAttempt = step.attempt;
+                    span?.setAttributes({
+                        ...Attribute.StepAttempt(currentAttempt),
+                        ...Attribute.StepMaxRetries(maxRetries),
+                    });
+                    // Note: maxRetries is the number of RETRIES after the first attempt, so total attempts = maxRetries + 1
+                    if (currentAttempt >= maxRetries + 1) {
+                        // Max retries reached
+                        const errorStack = getErrorStack(err);
+                        const stackLines = errorStack.split('\n').slice(0, 4);
+                        const retryCount = step.attempt - 1;
+                        console.error(`[Workflows] "${workflowRunId}" - Encountered \`Error\` while executing step "${stepName}" (attempt ${step.attempt}, ${retryCount} ${pluralize('retry', 'retries', retryCount)}):\n  > ${stackLines.join('\n    > ')}\n\n  Max retries reached\n  Bubbling error to parent workflow`);
+                        const errorMessage = `Step "${stepName}" failed after ${maxRetries} ${pluralize('retry', 'retries', maxRetries)}: ${String(err)}`;
+                        // Fail the step via event (event-sourced architecture)
+                        await world.events.create(workflowRunId, {
+                            eventType: 'step_failed',
+                            specVersion: SPEC_VERSION_CURRENT,
+                            correlationId: stepId,
+                            eventData: {
+                                error: errorMessage,
+                                stack: errorStack,
+                            },
+                        });
+                        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 ${currentAttempt}):\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 ${currentAttempt}):\n  > ${stackLines.join('\n    > ')}\n\n  This step has failed but will be retried`);
+                        }
+                        // Set step to pending for retry via event (event-sourced architecture)
+                        // step_retrying records the error and sets status to pending
+                        const errorStack = getErrorStack(err);
+                        await world.events.create(workflowRunId, {
+                            eventType: 'step_retrying',
+                            specVersion: SPEC_VERSION_CURRENT,
+                            correlationId: stepId,
+                            eventData: {
+                                error: String(err),
+                                stack: errorStack,
+                                ...(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 queueMessage(world, `__wkf_workflow_${workflowName}`, {
+                runId: workflowRunId,
+                traceCarrier: await serializeTraceCarrier(),
+                requestedAt: new Date(),
+            });
+        });
+    });
+});
+/**
+ * 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__ */ withHealthCheck(stepHandler);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"step-handler.js","sourceRoot":"","sources":["../../src/runtime/step-handler.ts"],"names":[],"mappings":"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"}

package/dist/runtime/suspension-handler.d.ts

@@ -0,0 +1,25 @@
+import type { Span } from '@opentelemetry/api';
+import { type World } from '@workflow/world';
+import type { WorkflowSuspension } from '../global.js';
+export interface SuspensionHandlerParams {
+    suspension: WorkflowSuspension;
+    world: World;
+    runId: string;
+    workflowName: string;
+    workflowStartedAt: number;
+    span?: Span;
+}
+export interface SuspensionHandlerResult {
+    timeoutSeconds?: number;
+}
+/**
+ * Handles a workflow suspension by processing all pending operations (hooks, steps, waits).
+ * Uses an event-sourced architecture where entities (steps, hooks) are created atomically
+ * with their corresponding events via events.create().
+ *
+ * Processing order:
+ * 1. Hooks are processed first to prevent race conditions with webhook receivers
+ * 2. Steps and waits are processed in parallel after hooks complete
+ */
+export declare function handleSuspension({ suspension, world, runId, workflowName, workflowStartedAt, span, }: SuspensionHandlerParams): Promise<SuspensionHandlerResult>;
+//# sourceMappingURL=suspension-handler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"suspension-handler.d.ts","sourceRoot":"","sources":["../../src/runtime/suspension-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAC;AAG/C,OAAO,EAIL,KAAK,KAAK,EACX,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAIV,kBAAkB,EACnB,MAAM,cAAc,CAAC;AAMtB,MAAM,WAAW,uBAAuB;IACtC,UAAU,EAAE,kBAAkB,CAAC;IAC/B,KAAK,EAAE,KAAK,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,MAAM,CAAC;IACrB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,IAAI,CAAC,EAAE,IAAI,CAAC;CACb;AAED,MAAM,WAAW,uBAAuB;IACtC,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;;;GAQG;AACH,wBAAsB,gBAAgB,CAAC,EACrC,UAAU,EACV,KAAK,EACL,KAAK,EACL,YAAY,EACZ,iBAAiB,EACjB,IAAI,GACL,EAAE,uBAAuB,GAAG,OAAO,CAAC,uBAAuB,CAAC,CA2M5D"}

package/dist/runtime/suspension-handler.js

@@ -0,0 +1,182 @@
+import { waitUntil } from '@vercel/functions';
+import { WorkflowAPIError } from '@workflow/errors';
+import { SPEC_VERSION_CURRENT, } from '@workflow/world';
+import { dehydrateStepArguments } from '../serialization.js';
+import * as Attribute from '../telemetry/semantic-conventions.js';
+import { serializeTraceCarrier } from '../telemetry.js';
+import { queueMessage } from './helpers.js';
+/**
+ * Handles a workflow suspension by processing all pending operations (hooks, steps, waits).
+ * Uses an event-sourced architecture where entities (steps, hooks) are created atomically
+ * with their corresponding events via events.create().
+ *
+ * Processing order:
+ * 1. Hooks are processed first to prevent race conditions with webhook receivers
+ * 2. Steps and waits are processed in parallel after hooks complete
+ */
+export async function handleSuspension({ suspension, world, runId, workflowName, workflowStartedAt, span, }) {
+    // Separate queue items by type
+    const stepItems = suspension.steps.filter((item) => item.type === 'step');
+    const hookItems = suspension.steps.filter((item) => item.type === 'hook');
+    const waitItems = suspension.steps.filter((item) => item.type === 'wait');
+    // Build hook_created events (World will atomically create hook entities)
+    const hookEvents = hookItems.map((queueItem) => {
+        const hookMetadata = typeof queueItem.metadata === 'undefined'
+            ? undefined
+            : dehydrateStepArguments(queueItem.metadata, suspension.globalThis);
+        return {
+            eventType: 'hook_created',
+            specVersion: SPEC_VERSION_CURRENT,
+            correlationId: queueItem.correlationId,
+            eventData: {
+                token: queueItem.token,
+                metadata: hookMetadata,
+            },
+        };
+    });
+    // Process hooks first to prevent race conditions with webhook receivers
+    // All hook creations run in parallel
+    // Track any hook conflicts that occur - these will be handled by re-enqueueing the workflow
+    let hasHookConflict = false;
+    if (hookEvents.length > 0) {
+        await Promise.all(hookEvents.map(async (hookEvent) => {
+            try {
+                const result = await world.events.create(runId, hookEvent);
+                // Check if the world returned a hook_conflict event instead of hook_created
+                // The hook_conflict event is stored in the event log and will be replayed
+                // on the next workflow invocation, causing the hook's promise to reject
+                // Note: hook events always create an event (legacy runs throw, not return undefined)
+                if (result.event.eventType === 'hook_conflict') {
+                    hasHookConflict = true;
+                }
+            }
+            catch (err) {
+                if (WorkflowAPIError.is(err)) {
+                    if (err.status === 410) {
+                        console.warn(`Workflow run "${runId}" has already completed, skipping hook: ${err.message}`);
+                    }
+                    else {
+                        throw err;
+                    }
+                }
+                else {
+                    throw err;
+                }
+            }
+        }));
+    }
+    // Build a map of stepId -> step event for steps that need creation
+    const stepsNeedingCreation = new Set(stepItems
+        .filter((queueItem) => !queueItem.hasCreatedEvent)
+        .map((queueItem) => queueItem.correlationId));
+    // Process steps and waits in parallel
+    // Each step: create event (if needed) -> queue message
+    // Each wait: create event (if needed)
+    const ops = [];
+    // Steps: create event then queue message, all in parallel
+    for (const queueItem of stepItems) {
+        ops.push((async () => {
+            // Create step event if not already created
+            if (stepsNeedingCreation.has(queueItem.correlationId)) {
+                const dehydratedInput = dehydrateStepArguments({
+                    args: queueItem.args,
+                    closureVars: queueItem.closureVars,
+                    thisVal: queueItem.thisVal,
+                }, suspension.globalThis);
+                const stepEvent = {
+                    eventType: 'step_created',
+                    specVersion: SPEC_VERSION_CURRENT,
+                    correlationId: queueItem.correlationId,
+                    eventData: {
+                        stepName: queueItem.stepName,
+                        input: dehydratedInput,
+                    },
+                };
+                try {
+                    await world.events.create(runId, stepEvent);
+                }
+                catch (err) {
+                    if (WorkflowAPIError.is(err) && err.status === 409) {
+                        console.warn(`Step already exists, continuing: ${err.message}`);
+                    }
+                    else {
+                        throw err;
+                    }
+                }
+            }
+            // Queue step execution message
+            await queueMessage(world, `__wkf_step_${queueItem.stepName}`, {
+                workflowName,
+                workflowRunId: runId,
+                workflowStartedAt,
+                stepId: queueItem.correlationId,
+                traceCarrier: await serializeTraceCarrier(),
+                requestedAt: new Date(),
+            }, {
+                idempotencyKey: queueItem.correlationId,
+            });
+        })());
+    }
+    // Waits: create events in parallel (no queueing needed for waits)
+    for (const queueItem of waitItems) {
+        if (!queueItem.hasCreatedEvent) {
+            ops.push((async () => {
+                const waitEvent = {
+                    eventType: 'wait_created',
+                    specVersion: SPEC_VERSION_CURRENT,
+                    correlationId: queueItem.correlationId,
+                    eventData: {
+                        resumeAt: queueItem.resumeAt,
+                    },
+                };
+                try {
+                    await world.events.create(runId, waitEvent);
+                }
+                catch (err) {
+                    if (WorkflowAPIError.is(err) && err.status === 409) {
+                        console.warn(`Wait already exists, continuing: ${err.message}`);
+                    }
+                    else {
+                        throw err;
+                    }
+                }
+            })());
+        }
+    }
+    // Wait for all step and wait operations to complete
+    waitUntil(Promise.all(ops).catch((opErr) => {
+        const isAbortError = opErr?.name === 'AbortError' || opErr?.name === 'ResponseAborted';
+        if (!isAbortError)
+            throw opErr;
+    }));
+    await Promise.all(ops);
+    // Calculate minimum timeout from waits
+    const now = Date.now();
+    const minTimeoutSeconds = waitItems.reduce((min, queueItem) => {
+        const resumeAtMs = queueItem.resumeAt.getTime();
+        const delayMs = Math.max(1000, resumeAtMs - now);
+        const timeoutSeconds = Math.ceil(delayMs / 1000);
+        if (min === null)
+            return timeoutSeconds;
+        return Math.min(min, timeoutSeconds);
+    }, null);
+    span?.setAttributes({
+        ...Attribute.WorkflowRunStatus('workflow_suspended'),
+        ...Attribute.WorkflowStepsCreated(stepItems.length),
+        ...Attribute.WorkflowHooksCreated(hookItems.length),
+        ...Attribute.WorkflowWaitsCreated(waitItems.length),
+    });
+    // If any hook conflicts occurred, re-enqueue the workflow immediately
+    // On the next iteration, the hook consumer will see the hook_conflict event
+    // and reject the promise with a WorkflowRuntimeError
+    // We do this after processing all other operations (steps, waits) to ensure
+    // they are recorded in the event log before the re-execution
+    if (hasHookConflict) {
+        return { timeoutSeconds: 1 };
+    }
+    if (minTimeoutSeconds !== null) {
+        return { timeoutSeconds: minTimeoutSeconds };
+    }
+    return {};
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/runtime/world.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"world.d.ts","sourceRoot":"","sources":["../../src/runtime/world.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAiB7C;;;;GAIG;AACH,eAAO,MAAM,WAAW,QAAO,KAkC9B,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,QAAO,IAAI,CAAC,KAAK,EAAE,oBAAoB,CASnE,CAAC;AAEF,eAAO,MAAM,QAAQ,QAAO,KAM3B,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,QAAQ,GAAI,OAAO,KAAK,GAAG,SAAS,KAAG,IAGnD,CAAC"}
+{"version":3,"file":"world.d.ts","sourceRoot":"","sources":["../../src/runtime/world.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAsB7C;;;;GAIG;AACH,eAAO,MAAM,WAAW,QAAO,KAgC9B,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,QAAO,IAAI,CAAC,KAAK,EAAE,oBAAoB,CASnE,CAAC;AAEF,eAAO,MAAM,QAAQ,QAAO,KAM3B,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,QAAQ,GAAI,OAAO,KAAK,GAAG,SAAS,KAAG,IAGnD,CAAC"}