@workflow/world-testing 4.1.0-beta.55 → 4.1.0-beta.56

package/dist/.well-known/workflow/v1/manifest.json

@@ -1,6 +1,11 @@
 {
     "version": "1.0.0",
     "steps": {
+        "workflows/addition.ts": {
+            "add": {
+                "stepId": "step//./workflows/addition//add"
+            }
+        },
         "workflow/dist/internal/builtins.js": {
             "__builtin_response_array_buffer": {
                 "stepId": "__builtin_response_array_buffer"
@@ -12,12 +17,14 @@
                 "stepId": "__builtin_response_text"
             }
         },
-        "workflows/retriable-and-fatal.ts": {
-            "stepThatFails": {
-                "stepId": "step//./workflows/retriable-and-fatal//stepThatFails"
-            },
-            "stepThatThrowsRetryableError": {
-                "stepId": "step//./workflows/retriable-and-fatal//stepThatThrowsRetryableError"
+        "workflow/dist/stdlib.js": {
+            "fetch": {
+                "stepId": "step//workflow@4.1.0-beta.55//fetch"
+            }
+        },
+        "workflows/hooks.ts": {
+            "writeEvent": {
+                "stepId": "step//./workflows/hooks//writeEvent"
             }
         },
         "workflows/noop.ts": {
@@ -25,49 +32,42 @@
                 "stepId": "step//./workflows/noop//noop"
             }
         },
-        "workflow/dist/stdlib.js": {
-            "fetch": {
-                "stepId": "step//workflow@4.1.0-beta.54//fetch"
-            }
-        },
-        "workflows/addition.ts": {
-            "add": {
-                "stepId": "step//./workflows/addition//add"
-            }
-        },
         "workflows/null-byte.ts": {
             "nullByteStep": {
                 "stepId": "step//./workflows/null-byte//nullByteStep"
             }
         },
-        "workflows/hooks.ts": {
-            "writeEvent": {
-                "stepId": "step//./workflows/hooks//writeEvent"
+        "workflows/retriable-and-fatal.ts": {
+            "stepThatFails": {
+                "stepId": "step//./workflows/retriable-and-fatal//stepThatFails"
+            },
+            "stepThatThrowsRetryableError": {
+                "stepId": "step//./workflows/retriable-and-fatal//stepThatThrowsRetryableError"
             }
         }
     },
     "workflows": {
-        "workflows/retriable-and-fatal.ts": {
-            "retryableAndFatalErrorWorkflow": {
-                "workflowId": "workflow//./workflows/retriable-and-fatal//retryableAndFatalErrorWorkflow",
+        "workflows/addition.ts": {
+            "addition": {
+                "workflowId": "workflow//./workflows/addition//addition",
                 "graph": {
                     "nodes": [],
                     "edges": []
                 }
             }
         },
-        "workflows/noop.ts": {
-            "brokenWf": {
-                "workflowId": "workflow//./workflows/noop//brokenWf",
+        "workflows/hooks.ts": {
+            "collectWithHook": {
+                "workflowId": "workflow//./workflows/hooks//collectWithHook",
                 "graph": {
                     "nodes": [],
                     "edges": []
                 }
             }
         },
-        "workflows/addition.ts": {
-            "addition": {
-                "workflowId": "workflow//./workflows/addition//addition",
+        "workflows/noop.ts": {
+            "brokenWf": {
+                "workflowId": "workflow//./workflows/noop//brokenWf",
                 "graph": {
                     "nodes": [],
                     "edges": []
@@ -83,9 +83,9 @@
                 }
             }
         },
-        "workflows/hooks.ts": {
-            "collectWithHook": {
-                "workflowId": "workflow//./workflows/hooks//collectWithHook",
+        "workflows/retriable-and-fatal.ts": {
+            "retryableAndFatalErrorWorkflow": {
+                "workflowId": "workflow//./workflows/retriable-and-fatal//retryableAndFatalErrorWorkflow",
                 "graph": {
                     "nodes": [],
                     "edges": []

package/dist/.well-known/workflow/v1/step.js

@@ -25120,13 +25120,54 @@ var import_node_async_hooks = require("node:async_hooks");
 var contextStorage = /* @__PURE__ */ new import_node_async_hooks.AsyncLocalStorage();
 // ../core/dist/private.js
 var registeredSteps = /* @__PURE__ */ new Map();
+function getStepIdAliasCandidates(stepId) {
+    const parts = stepId.split("//");
+    if (parts.length !== 3 || parts[0] !== "step") {
+        return [];
+    }
+    const modulePath = parts[1];
+    const fnName = parts[2];
+    const modulePathAliases = /* @__PURE__ */ new Set();
+    const addAlias = /* @__PURE__ */ __name((aliasModulePath) => {
+        if (aliasModulePath !== modulePath) {
+            modulePathAliases.add(aliasModulePath);
+        }
+    }, "addAlias");
+    if (modulePath.startsWith("./workflows/")) {
+        const workflowRelativePath = modulePath.slice("./".length);
+        addAlias(`./example/${workflowRelativePath}`);
+        addAlias(`./src/${workflowRelativePath}`);
+    }
+    else if (modulePath.startsWith("./example/workflows/")) {
+        const workflowRelativePath = modulePath.slice("./example/".length);
+        addAlias(`./${workflowRelativePath}`);
+        addAlias(`./src/${workflowRelativePath}`);
+    }
+    else if (modulePath.startsWith("./src/workflows/")) {
+        const workflowRelativePath = modulePath.slice("./src/".length);
+        addAlias(`./${workflowRelativePath}`);
+        addAlias(`./example/${workflowRelativePath}`);
+    }
+    return Array.from(modulePathAliases, (aliasModulePath) => `step//${aliasModulePath}//${fnName}`);
+}
+__name(getStepIdAliasCandidates, "getStepIdAliasCandidates");
 function registerStepFunction(stepId, stepFn) {
     registeredSteps.set(stepId, stepFn);
     stepFn.stepId = stepId;
 }
 __name(registerStepFunction, "registerStepFunction");
 function getStepFunction(stepId) {
-    return registeredSteps.get(stepId);
+    const directMatch = registeredSteps.get(stepId);
+    if (directMatch) {
+        return directMatch;
+    }
+    for (const aliasStepId of getStepIdAliasCandidates(stepId)) {
+        const aliasMatch = registeredSteps.get(aliasStepId);
+        if (aliasMatch) {
+            return aliasMatch;
+        }
+    }
+    return void 0;
 }
 __name(getStepFunction, "getStepFunction");
 // ../workflow/dist/internal/builtins.js
@@ -25145,6 +25186,12 @@ __name(__builtin_response_text, "__builtin_response_text");
 registerStepFunction("__builtin_response_array_buffer", __builtin_response_array_buffer);
 registerStepFunction("__builtin_response_json", __builtin_response_json);
 registerStepFunction("__builtin_response_text", __builtin_response_text);
+// ../workflow/dist/stdlib.js
+async function fetch2(...args) {
+    return globalThis.fetch(...args);
+}
+__name(fetch2, "fetch");
+registerStepFunction("step//workflow@4.1.0-beta.55//fetch", fetch2);
 // workflows/addition.ts
 async function add(num, num2) {
     return num + num2;
@@ -25248,6 +25295,8 @@ var WorkflowAPIError = class extends WorkflowError {
     status;
     code;
     url;
+    /** Retry-After value in seconds, present on 429 responses */
+    retryAfter;
     constructor(message, options) {
         super(message, {
             cause: options?.cause
@@ -25256,6 +25305,7 @@ var WorkflowAPIError = class extends WorkflowError {
         this.status = options?.status;
         this.code = options?.code;
         this.url = options?.url;
+        this.retryAfter = options?.retryAfter;
     }
     static is(value) {
         return isError(value) && value.name === "WorkflowAPIError";
@@ -39387,7 +39437,9 @@ var TraceCarrierSchema = external_exports.record(external_exports.string(), exte
 var WorkflowInvokePayloadSchema = external_exports.object({
     runId: external_exports.string(),
     traceCarrier: TraceCarrierSchema.optional(),
-    requestedAt: external_exports.coerce.date().optional()
+    requestedAt: external_exports.coerce.date().optional(),
+    /** Number of times this message has been re-enqueued due to server errors (5xx) */
+    serverErrorRetryCount: external_exports.number().int().optional()
 });
 var StepInvokePayloadSchema = external_exports.object({
     workflowName: external_exports.string(),
@@ -47169,7 +47221,7 @@ var RpcSystem3 = SemanticConvention3("rpc.system");
 var RpcService3 = SemanticConvention3("rpc.service");
 var RpcMethod3 = SemanticConvention3("rpc.method");
 // ../world-vercel/dist/version.js
-var version2 = "4.1.0-beta.31";
+var version2 = "4.1.0-beta.32";
 // ../world-vercel/dist/utils.js
 var WORKFLOW_SERVER_URL_OVERRIDE = "";
 var DEFAULT_RESOLVE_DATA_OPTION2 = "all";
@@ -47317,10 +47369,21 @@ async function makeRequest({ endpoint, options = {}, config: config3 = {}, schem
                 console.error(`Failed to fetch, reproduce with:
 curl -X ${request.method} ${stringifiedHeaders} "${url2}"`);
             }
+            let retryAfter;
+            if (response.status === 429) {
+                const retryAfterHeader = response.headers.get("Retry-After");
+                if (retryAfterHeader) {
+                    const parsed = parseInt(retryAfterHeader, 10);
+                    if (!Number.isNaN(parsed)) {
+                        retryAfter = parsed;
+                    }
+                }
+            }
             const error45 = new WorkflowAPIError(errorData.message || `${request.method} ${endpoint} -> HTTP ${response.status}: ${response.statusText}`, {
                 url: url2,
                 status: response.status,
-                code: errorData.code
+                code: errorData.code,
+                retryAfter
             });
             span?.setAttributes({
                 ...ErrorType2(errorData.code || `HTTP ${response.status}`)
@@ -48856,7 +48919,7 @@ async function waitedUntil(fn) {
 }
 __name(waitedUntil, "waitedUntil");
 // ../core/dist/runtime/helpers.js
-var SAFE_WORKFLOW_NAME_PATTERN = /^[a-zA-Z0-9_\-.\/]+$/;
+var SAFE_WORKFLOW_NAME_PATTERN = /^[a-zA-Z0-9_\-./]+$/;
 function getWorkflowQueueName(workflowName) {
     if (!SAFE_WORKFLOW_NAME_PATTERN.test(workflowName)) {
         throw new Error(`Invalid workflow name "${workflowName}": must only contain alphanumeric characters, underscores, hyphens, dots, or forward slashes`);
@@ -49057,12 +49120,6 @@ function getStepMetadata() {
     return ctx.stepMetadata;
 }
 __name(getStepMetadata, "getStepMetadata");
-// ../workflow/dist/stdlib.js
-async function fetch2(...args) {
-    return globalThis.fetch(...args);
-}
-__name(fetch2, "fetch");
-registerStepFunction("step//workflow@4.1.0-beta.54//fetch", fetch2);
 // workflows/hooks.ts
 var Hook = defineHook({
     schema: object({
@@ -49100,6 +49157,17 @@ async function brokenWf() {
 __name(brokenWf, "brokenWf");
 brokenWf.workflowId = "workflow//./workflows/noop//brokenWf";
 registerStepFunction("step//./workflows/noop//noop", noop);
+// workflows/null-byte.ts
+async function nullByteStep() {
+    return "null byte \0";
+}
+__name(nullByteStep, "nullByteStep");
+async function nullByteWorkflow() {
+    throw new Error("You attempted to execute workflow nullByteWorkflow function directly. To start a workflow, use start(nullByteWorkflow) from workflow/api");
+}
+__name(nullByteWorkflow, "nullByteWorkflow");
+nullByteWorkflow.workflowId = "workflow//./workflows/null-byte//nullByteWorkflow";
+registerStepFunction("step//./workflows/null-byte//nullByteStep", nullByteStep);
 // workflows/retriable-and-fatal.ts
 async function retryableAndFatalErrorWorkflow() {
     throw new Error("You attempted to execute workflow retryableAndFatalErrorWorkflow function directly. To start a workflow, use start(retryableAndFatalErrorWorkflow) from workflow/api");
@@ -49127,17 +49195,6 @@ async function stepThatFails() {
 __name(stepThatFails, "stepThatFails");
 registerStepFunction("step//./workflows/retriable-and-fatal//stepThatThrowsRetryableError", stepThatThrowsRetryableError);
 registerStepFunction("step//./workflows/retriable-and-fatal//stepThatFails", stepThatFails);
-// workflows/null-byte.ts
-async function nullByteStep() {
-    return "null byte \0";
-}
-__name(nullByteStep, "nullByteStep");
-async function nullByteWorkflow() {
-    throw new Error("You attempted to execute workflow nullByteWorkflow function directly. To start a workflow, use start(nullByteWorkflow) from workflow/api");
-}
-__name(nullByteWorkflow, "nullByteWorkflow");
-nullByteWorkflow.workflowId = "workflow//./workflows/null-byte//nullByteWorkflow";
-registerStepFunction("step//./workflows/null-byte//nullByteStep", nullByteStep);
 // ../core/dist/runtime/suspension-handler.js
 var import_functions3 = __toESM(require_functions(), 1);
 // ../../node_modules/.pnpm/@jridgewell+sourcemap-codec@1.5.5/node_modules/@jridgewell/sourcemap-codec/dist/sourcemap-codec.mjs
@@ -49168,6 +49225,62 @@ function getErrorStack(v) {
     return "";
 }
 __name(getErrorStack, "getErrorStack");
+function isThenable(value) {
+    return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
+}
+__name(isThenable, "isThenable");
+function normalizeSyncError(v) {
+    if (import_node_util3.types.isNativeError(v)) {
+        return {
+            name: v.name,
+            message: v.message,
+            stack: v.stack ?? ""
+        };
+    }
+    if (typeof v === "string") {
+        return {
+            name: "Error",
+            message: v,
+            stack: ""
+        };
+    }
+    try {
+        return {
+            name: "Error",
+            message: JSON.stringify(v),
+            stack: ""
+        };
+    }
+    catch {
+        return {
+            name: "Error",
+            message: String(v),
+            stack: ""
+        };
+    }
+}
+__name(normalizeSyncError, "normalizeSyncError");
+async function normalizeUnknownError(value) {
+    if (isThenable(value)) {
+        try {
+            const resolved = await value;
+            const normalized = await normalizeUnknownError(resolved);
+            return {
+                ...normalized,
+                message: `Promise rejection: ${normalized.message}`
+            };
+        }
+        catch (rejection) {
+            const normalized = await normalizeUnknownError(rejection);
+            return {
+                ...normalized,
+                message: `Promise rejection: ${normalized.message}`
+            };
+        }
+    }
+    return normalizeSyncError(value);
+}
+__name(normalizeUnknownError, "normalizeUnknownError");
 // ../core/dist/events-consumer.js
 var EventConsumerResult;
 (function (EventConsumerResult2) {
@@ -49243,6 +49356,15 @@ var stepHandler = getWorldHandlers().createQueueHandler("__wkf_step_", async (me
             }
             catch (err) {
                 if (WorkflowAPIError.is(err)) {
+                    if (WorkflowAPIError.is(err) && err.status === 429) {
+                        const retryRetryAfter = Math.max(1, typeof err.retryAfter === "number" ? err.retryAfter : 1);
+                        runtimeLogger.warn("Throttled again on retry, deferring to queue", {
+                            retryAfterSeconds: retryRetryAfter
+                        });
+                        return {
+                            timeoutSeconds: retryRetryAfter
+                        };
+                    }
                     if (err.status === 410) {
                         console.warn(`Workflow run "${workflowRunId}" has already completed, skipping step "${stepId}": ${err.message}`);
                         return;
@@ -49418,6 +49540,8 @@ var stepHandler = getWorldHandlers().createQueueHandler("__wkf_step_", async (me
                 return;
             }
             catch (err) {
+                const normalizedError = await normalizeUnknownError(err);
+                const normalizedStack = normalizedError.stack || getErrorStack(err) || "";
                 if (err instanceof Error) {
                     span?.recordException?.(err);
                 }
@@ -49426,7 +49550,7 @@ var stepHandler = getWorldHandlers().createQueueHandler("__wkf_step_", async (me
                 const errorCategory = isFatal ? "fatal" : isRetryable ? "retryable" : "transient";
                 span?.setAttributes({
                     ...StepErrorName(getErrorName(err)),
-                    ...StepErrorMessage(String(err)),
+                    ...StepErrorMessage(normalizedError.message),
                     ...ErrorType(getErrorName(err)),
                     ...ErrorCategory(errorCategory),
                     ...ErrorRetryable(!isFatal)
@@ -49442,19 +49566,18 @@ var stepHandler = getWorldHandlers().createQueueHandler("__wkf_step_", async (me
                     }
                 }
                 if (isFatal) {
-                    const errorStack = getErrorStack(err);
                     stepLogger.error("Encountered FatalError while executing step, bubbling up to parent workflow", {
                         workflowRunId,
                         stepName,
-                        errorStack
+                        errorStack: normalizedStack
                     });
                     await world.events.create(workflowRunId, {
                         eventType: "step_failed",
                         specVersion: SPEC_VERSION_CURRENT,
                         correlationId: stepId,
                         eventData: {
-                            error: String(err),
-                            stack: errorStack
+                            error: normalizedError.message,
+                            stack: normalizedStack
                         }
                     });
                     span?.setAttributes({
@@ -49470,23 +49593,22 @@ var stepHandler = getWorldHandlers().createQueueHandler("__wkf_step_", async (me
                         ...StepMaxRetries(maxRetries2)
                     });
                     if (currentAttempt >= maxRetries2 + 1) {
-                        const errorStack = getErrorStack(err);
                         const retryCount = step.attempt - 1;
                         stepLogger.error("Max retries reached, bubbling error to parent workflow", {
                             workflowRunId,
                             stepName,
                             attempt: step.attempt,
                             retryCount,
-                            errorStack
+                            errorStack: normalizedStack
                         });
-                        const errorMessage = `Step "${stepName}" failed after ${maxRetries2} ${pluralize("retry", "retries", maxRetries2)}: ${String(err)}`;
+                        const errorMessage = `Step "${stepName}" failed after ${maxRetries2} ${pluralize("retry", "retries", maxRetries2)}: ${normalizedError.message}`;
                         await world.events.create(workflowRunId, {
                             eventType: "step_failed",
                             specVersion: SPEC_VERSION_CURRENT,
                             correlationId: stepId,
                             eventData: {
                                 error: errorMessage,
-                                stack: errorStack
+                                stack: normalizedStack
                             }
                         });
                         span?.setAttributes({
@@ -49504,22 +49626,20 @@ var stepHandler = getWorldHandlers().createQueueHandler("__wkf_step_", async (me
                             });
                         }
                         else {
-                            const errorStack2 = getErrorStack(err);
                             stepLogger.warn("Encountered Error, step will be retried", {
                                 workflowRunId,
                                 stepName,
                                 attempt: currentAttempt,
-                                errorStack: errorStack2
+                                errorStack: normalizedStack
                             });
                         }
-                        const errorStack = getErrorStack(err);
                         await world.events.create(workflowRunId, {
                             eventType: "step_retrying",
                             specVersion: SPEC_VERSION_CURRENT,
                             correlationId: stepId,
                             eventData: {
-                                error: String(err),
-                                stack: errorStack,
+                                error: normalizedError.message,
+                                stack: normalizedStack,
                                 ...RetryableError.is(err) && {
                                     retryAfter: err.retryAfter
                                 }