@workflow/world-testing 4.0.1-beta.33 → 4.0.1-beta.35

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

@@ -488,11 +488,11 @@ var require_wait_until = __commonJS({
         }), mod), "__toCommonJS");
         var wait_until_exports = {};
         __export2(wait_until_exports, {
-            waitUntil: /* @__PURE__ */ __name(() => waitUntil6, "waitUntil")
+            waitUntil: /* @__PURE__ */ __name(() => waitUntil7, "waitUntil")
         });
         module2.exports = __toCommonJS2(wait_until_exports);
         var import_get_context = require_get_context();
-        var waitUntil6 = /* @__PURE__ */ __name((promise2) => {
+        var waitUntil7 = /* @__PURE__ */ __name((promise2) => {
             if (promise2 === null || typeof promise2 !== "object" || typeof promise2.then !== "function") {
                 throw new TypeError(`waitUntil can only be called with a Promise, got ${typeof promise2}`);
             }
@@ -24511,30 +24511,6 @@ __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);
-// workflows/addition.ts
-async function add(num, num2) {
-    return num + num2;
-}
-__name(add, "add");
-async function addition(num, num2) {
-    throw new Error("You attempted to execute workflow addition function directly. To start a workflow, use start(addition) from workflow/api");
-}
-__name(addition, "addition");
-addition.workflowId = "workflow//workflows/addition.ts//addition";
-registerStepFunction("step//workflows/addition.ts//add", add);
-// workflows/noop.ts
-var count = 0;
-async function noop(_i) {
-    count++;
-    return count;
-}
-__name(noop, "noop");
-async function brokenWf() {
-    throw new Error("You attempted to execute workflow brokenWf function directly. To start a workflow, use start(brokenWf) from workflow/api");
-}
-__name(brokenWf, "brokenWf");
-brokenWf.workflowId = "workflow//workflows/noop.ts//brokenWf";
-registerStepFunction("step//workflows/noop.ts//noop", noop);
 // ../utils/dist/index.js
 var import_ms = __toESM(require_ms(), 1);
 function once(fn) {
@@ -25209,6 +25185,169 @@ function stringify_primitive(thing) {
     return String(thing);
 }
 __name(stringify_primitive, "stringify_primitive");
+// ../../node_modules/.pnpm/ulid@3.0.1/node_modules/ulid/dist/node/index.js
+var import_node_crypto = __toESM(require("node:crypto"), 1);
+var ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+var ENCODING_LEN = 32;
+var RANDOM_LEN = 16;
+var TIME_LEN = 10;
+var TIME_MAX = 281474976710655;
+var ULIDErrorCode;
+(function (ULIDErrorCode2) {
+    ULIDErrorCode2["Base32IncorrectEncoding"] = "B32_ENC_INVALID";
+    ULIDErrorCode2["DecodeTimeInvalidCharacter"] = "DEC_TIME_CHAR";
+    ULIDErrorCode2["DecodeTimeValueMalformed"] = "DEC_TIME_MALFORMED";
+    ULIDErrorCode2["EncodeTimeNegative"] = "ENC_TIME_NEG";
+    ULIDErrorCode2["EncodeTimeSizeExceeded"] = "ENC_TIME_SIZE_EXCEED";
+    ULIDErrorCode2["EncodeTimeValueMalformed"] = "ENC_TIME_MALFORMED";
+    ULIDErrorCode2["PRNGDetectFailure"] = "PRNG_DETECT";
+    ULIDErrorCode2["ULIDInvalid"] = "ULID_INVALID";
+    ULIDErrorCode2["Unexpected"] = "UNEXPECTED";
+    ULIDErrorCode2["UUIDInvalid"] = "UUID_INVALID";
+})(ULIDErrorCode || (ULIDErrorCode = {}));
+var ULIDError = class extends Error {
+    static {
+        __name(this, "ULIDError");
+    }
+    constructor(errorCode, message) {
+        super(`${message} (${errorCode})`);
+        this.name = "ULIDError";
+        this.code = errorCode;
+    }
+};
+function randomChar(prng) {
+    const randomPosition = Math.floor(prng() * ENCODING_LEN) % ENCODING_LEN;
+    return ENCODING.charAt(randomPosition);
+}
+__name(randomChar, "randomChar");
+function replaceCharAt(str, index, char) {
+    if (index > str.length - 1) {
+        return str;
+    }
+    return str.substr(0, index) + char + str.substr(index + 1);
+}
+__name(replaceCharAt, "replaceCharAt");
+function incrementBase32(str) {
+    let done = void 0, index = str.length, char, charIndex, output = str;
+    const maxCharIndex = ENCODING_LEN - 1;
+    while (!done && index-- >= 0) {
+        char = output[index];
+        charIndex = ENCODING.indexOf(char);
+        if (charIndex === -1) {
+            throw new ULIDError(ULIDErrorCode.Base32IncorrectEncoding, "Incorrectly encoded string");
+        }
+        if (charIndex === maxCharIndex) {
+            output = replaceCharAt(output, index, ENCODING[0]);
+            continue;
+        }
+        done = replaceCharAt(output, index, ENCODING[charIndex + 1]);
+    }
+    if (typeof done === "string") {
+        return done;
+    }
+    throw new ULIDError(ULIDErrorCode.Base32IncorrectEncoding, "Failed incrementing string");
+}
+__name(incrementBase32, "incrementBase32");
+function decodeTime(id) {
+    if (id.length !== TIME_LEN + RANDOM_LEN) {
+        throw new ULIDError(ULIDErrorCode.DecodeTimeValueMalformed, "Malformed ULID");
+    }
+    const time3 = id.substr(0, TIME_LEN).toUpperCase().split("").reverse().reduce((carry, char, index) => {
+        const encodingIndex = ENCODING.indexOf(char);
+        if (encodingIndex === -1) {
+            throw new ULIDError(ULIDErrorCode.DecodeTimeInvalidCharacter, `Time decode error: Invalid character: ${char}`);
+        }
+        return carry += encodingIndex * Math.pow(ENCODING_LEN, index);
+    }, 0);
+    if (time3 > TIME_MAX) {
+        throw new ULIDError(ULIDErrorCode.DecodeTimeValueMalformed, `Malformed ULID: timestamp too large: ${time3}`);
+    }
+    return time3;
+}
+__name(decodeTime, "decodeTime");
+function detectPRNG(root) {
+    const rootLookup = detectRoot();
+    const globalCrypto = rootLookup && (rootLookup.crypto || rootLookup.msCrypto) || (typeof import_node_crypto.default !== "undefined" ? import_node_crypto.default : null);
+    if (typeof globalCrypto?.getRandomValues === "function") {
+        return () => {
+            const buffer = new Uint8Array(1);
+            globalCrypto.getRandomValues(buffer);
+            return buffer[0] / 255;
+        };
+    }
+    else if (typeof globalCrypto?.randomBytes === "function") {
+        return () => globalCrypto.randomBytes(1).readUInt8() / 255;
+    }
+    else if (import_node_crypto.default?.randomBytes) {
+        return () => import_node_crypto.default.randomBytes(1).readUInt8() / 255;
+    }
+    throw new ULIDError(ULIDErrorCode.PRNGDetectFailure, "Failed to find a reliable PRNG");
+}
+__name(detectPRNG, "detectPRNG");
+function detectRoot() {
+    if (inWebWorker())
+        return self;
+    if (typeof window !== "undefined") {
+        return window;
+    }
+    if (typeof global !== "undefined") {
+        return global;
+    }
+    if (typeof globalThis !== "undefined") {
+        return globalThis;
+    }
+    return null;
+}
+__name(detectRoot, "detectRoot");
+function encodeRandom(len, prng) {
+    let str = "";
+    for (; len > 0; len--) {
+        str = randomChar(prng) + str;
+    }
+    return str;
+}
+__name(encodeRandom, "encodeRandom");
+function encodeTime(now, len = TIME_LEN) {
+    if (isNaN(now)) {
+        throw new ULIDError(ULIDErrorCode.EncodeTimeValueMalformed, `Time must be a number: ${now}`);
+    }
+    else if (now > TIME_MAX) {
+        throw new ULIDError(ULIDErrorCode.EncodeTimeSizeExceeded, `Cannot encode a time larger than ${TIME_MAX}: ${now}`);
+    }
+    else if (now < 0) {
+        throw new ULIDError(ULIDErrorCode.EncodeTimeNegative, `Time must be positive: ${now}`);
+    }
+    else if (Number.isInteger(now) === false) {
+        throw new ULIDError(ULIDErrorCode.EncodeTimeValueMalformed, `Time must be an integer: ${now}`);
+    }
+    let mod, str = "";
+    for (let currentLen = len; currentLen > 0; currentLen--) {
+        mod = now % ENCODING_LEN;
+        str = ENCODING.charAt(mod) + str;
+        now = (now - mod) / ENCODING_LEN;
+    }
+    return str;
+}
+__name(encodeTime, "encodeTime");
+function inWebWorker() {
+    return typeof WorkerGlobalScope !== "undefined" && self instanceof WorkerGlobalScope;
+}
+__name(inWebWorker, "inWebWorker");
+function monotonicFactory(prng) {
+    const currentPRNG = prng || detectPRNG();
+    let lastTime = 0, lastRandom;
+    return /* @__PURE__ */ __name(function _ulid2(seedTime) {
+        const seed = !seedTime || isNaN(seedTime) ? Date.now() : seedTime;
+        if (seed <= lastTime) {
+            const incrementedRandom = lastRandom = incrementBase32(lastRandom);
+            return encodeTime(lastTime, TIME_LEN) + incrementedRandom;
+        }
+        lastTime = seed;
+        const newRandom = lastRandom = encodeRandom(RANDOM_LEN, currentPRNG);
+        return encodeTime(seed, TIME_LEN) + newRandom;
+    }, "_ulid");
+}
+__name(monotonicFactory, "monotonicFactory");
 // ../core/dist/runtime/world.js
 var import_node_module = require("node:module");
 var import_node_path4 = require("node:path");
@@ -41182,170 +41321,6 @@ var StepSchema = external_exports.object({
 });
 // ../world-local/dist/queue.js
 var import_async_sema = __toESM(require_lib(), 1);
-// ../../node_modules/.pnpm/ulid@3.0.1/node_modules/ulid/dist/node/index.js
-var import_node_crypto = __toESM(require("node:crypto"), 1);
-var ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
-var ENCODING_LEN = 32;
-var RANDOM_LEN = 16;
-var TIME_LEN = 10;
-var TIME_MAX = 281474976710655;
-var ULIDErrorCode;
-(function (ULIDErrorCode2) {
-    ULIDErrorCode2["Base32IncorrectEncoding"] = "B32_ENC_INVALID";
-    ULIDErrorCode2["DecodeTimeInvalidCharacter"] = "DEC_TIME_CHAR";
-    ULIDErrorCode2["DecodeTimeValueMalformed"] = "DEC_TIME_MALFORMED";
-    ULIDErrorCode2["EncodeTimeNegative"] = "ENC_TIME_NEG";
-    ULIDErrorCode2["EncodeTimeSizeExceeded"] = "ENC_TIME_SIZE_EXCEED";
-    ULIDErrorCode2["EncodeTimeValueMalformed"] = "ENC_TIME_MALFORMED";
-    ULIDErrorCode2["PRNGDetectFailure"] = "PRNG_DETECT";
-    ULIDErrorCode2["ULIDInvalid"] = "ULID_INVALID";
-    ULIDErrorCode2["Unexpected"] = "UNEXPECTED";
-    ULIDErrorCode2["UUIDInvalid"] = "UUID_INVALID";
-})(ULIDErrorCode || (ULIDErrorCode = {}));
-var ULIDError = class extends Error {
-    static {
-        __name(this, "ULIDError");
-    }
-    constructor(errorCode, message) {
-        super(`${message} (${errorCode})`);
-        this.name = "ULIDError";
-        this.code = errorCode;
-    }
-};
-function randomChar(prng) {
-    const randomPosition = Math.floor(prng() * ENCODING_LEN) % ENCODING_LEN;
-    return ENCODING.charAt(randomPosition);
-}
-__name(randomChar, "randomChar");
-function replaceCharAt(str, index, char) {
-    if (index > str.length - 1) {
-        return str;
-    }
-    return str.substr(0, index) + char + str.substr(index + 1);
-}
-__name(replaceCharAt, "replaceCharAt");
-function incrementBase32(str) {
-    let done = void 0, index = str.length, char, charIndex, output = str;
-    const maxCharIndex = ENCODING_LEN - 1;
-    while (!done && index-- >= 0) {
-        char = output[index];
-        charIndex = ENCODING.indexOf(char);
-        if (charIndex === -1) {
-            throw new ULIDError(ULIDErrorCode.Base32IncorrectEncoding, "Incorrectly encoded string");
-        }
-        if (charIndex === maxCharIndex) {
-            output = replaceCharAt(output, index, ENCODING[0]);
-            continue;
-        }
-        done = replaceCharAt(output, index, ENCODING[charIndex + 1]);
-    }
-    if (typeof done === "string") {
-        return done;
-    }
-    throw new ULIDError(ULIDErrorCode.Base32IncorrectEncoding, "Failed incrementing string");
-}
-__name(incrementBase32, "incrementBase32");
-function decodeTime(id) {
-    if (id.length !== TIME_LEN + RANDOM_LEN) {
-        throw new ULIDError(ULIDErrorCode.DecodeTimeValueMalformed, "Malformed ULID");
-    }
-    const time3 = id.substr(0, TIME_LEN).toUpperCase().split("").reverse().reduce((carry, char, index) => {
-        const encodingIndex = ENCODING.indexOf(char);
-        if (encodingIndex === -1) {
-            throw new ULIDError(ULIDErrorCode.DecodeTimeInvalidCharacter, `Time decode error: Invalid character: ${char}`);
-        }
-        return carry += encodingIndex * Math.pow(ENCODING_LEN, index);
-    }, 0);
-    if (time3 > TIME_MAX) {
-        throw new ULIDError(ULIDErrorCode.DecodeTimeValueMalformed, `Malformed ULID: timestamp too large: ${time3}`);
-    }
-    return time3;
-}
-__name(decodeTime, "decodeTime");
-function detectPRNG(root) {
-    const rootLookup = detectRoot();
-    const globalCrypto = rootLookup && (rootLookup.crypto || rootLookup.msCrypto) || (typeof import_node_crypto.default !== "undefined" ? import_node_crypto.default : null);
-    if (typeof globalCrypto?.getRandomValues === "function") {
-        return () => {
-            const buffer = new Uint8Array(1);
-            globalCrypto.getRandomValues(buffer);
-            return buffer[0] / 255;
-        };
-    }
-    else if (typeof globalCrypto?.randomBytes === "function") {
-        return () => globalCrypto.randomBytes(1).readUInt8() / 255;
-    }
-    else if (import_node_crypto.default?.randomBytes) {
-        return () => import_node_crypto.default.randomBytes(1).readUInt8() / 255;
-    }
-    throw new ULIDError(ULIDErrorCode.PRNGDetectFailure, "Failed to find a reliable PRNG");
-}
-__name(detectPRNG, "detectPRNG");
-function detectRoot() {
-    if (inWebWorker())
-        return self;
-    if (typeof window !== "undefined") {
-        return window;
-    }
-    if (typeof global !== "undefined") {
-        return global;
-    }
-    if (typeof globalThis !== "undefined") {
-        return globalThis;
-    }
-    return null;
-}
-__name(detectRoot, "detectRoot");
-function encodeRandom(len, prng) {
-    let str = "";
-    for (; len > 0; len--) {
-        str = randomChar(prng) + str;
-    }
-    return str;
-}
-__name(encodeRandom, "encodeRandom");
-function encodeTime(now, len = TIME_LEN) {
-    if (isNaN(now)) {
-        throw new ULIDError(ULIDErrorCode.EncodeTimeValueMalformed, `Time must be a number: ${now}`);
-    }
-    else if (now > TIME_MAX) {
-        throw new ULIDError(ULIDErrorCode.EncodeTimeSizeExceeded, `Cannot encode a time larger than ${TIME_MAX}: ${now}`);
-    }
-    else if (now < 0) {
-        throw new ULIDError(ULIDErrorCode.EncodeTimeNegative, `Time must be positive: ${now}`);
-    }
-    else if (Number.isInteger(now) === false) {
-        throw new ULIDError(ULIDErrorCode.EncodeTimeValueMalformed, `Time must be an integer: ${now}`);
-    }
-    let mod, str = "";
-    for (let currentLen = len; currentLen > 0; currentLen--) {
-        mod = now % ENCODING_LEN;
-        str = ENCODING.charAt(mod) + str;
-        now = (now - mod) / ENCODING_LEN;
-    }
-    return str;
-}
-__name(encodeTime, "encodeTime");
-function inWebWorker() {
-    return typeof WorkerGlobalScope !== "undefined" && self instanceof WorkerGlobalScope;
-}
-__name(inWebWorker, "inWebWorker");
-function monotonicFactory(prng) {
-    const currentPRNG = prng || detectPRNG();
-    let lastTime = 0, lastRandom;
-    return /* @__PURE__ */ __name(function _ulid2(seedTime) {
-        const seed = !seedTime || isNaN(seedTime) ? Date.now() : seedTime;
-        if (seed <= lastTime) {
-            const incrementedRandom = lastRandom = incrementBase32(lastRandom);
-            return encodeTime(lastTime, TIME_LEN) + incrementedRandom;
-        }
-        lastTime = seed;
-        const newRandom = lastRandom = encodeRandom(RANDOM_LEN, currentPRNG);
-        return encodeTime(seed, TIME_LEN) + newRandom;
-    }, "_ulid");
-}
-__name(monotonicFactory, "monotonicFactory");
-// ../world-local/dist/queue.js
 var import_undici = __toESM(require_undici(), 1);
 var LOCAL_QUEUE_MAX_VISIBILITY = parseInt(process.env.WORKFLOW_LOCAL_QUEUE_MAX_VISIBILITY ?? "0", 10) || Infinity;
 var DEFAULT_CONCURRENCY_LIMIT = 100;
@@ -41657,12 +41632,7 @@ async function paginatedFileSystemQuery(config3) {
                     return sortOrder === "desc" ? fileTime < cursorTime : fileTime > cursorTime;
                 }
             }
-            return false;
-        });
-    }
-    else {
-        candidateFileIds = relevantFileIds.filter((fileId) => {
-            return getCreatedAt(`${fileId}.json`) !== null;
+            return true;
         });
     }
     const validItems = [];
@@ -41766,9 +41736,7 @@ var getObjectCreatedAt = /* @__PURE__ */ __name((idPrefix) => (filename) => {
         return ulidToDate(ulid5);
     }
     if (idPrefix === "step") {
-        const runId = filename.substring(0, dashIndex);
-        const ulid5 = runId.replace(/^wrun_/, "");
-        return ulidToDate(ulid5);
+        return null;
     }
     const id = filename.substring(dashIndex + 1).replace(/\.json$/, "");
     const ulid4 = id.replace(replaceRegex, "");
@@ -42184,6 +42152,9 @@ __name(createStorage, "createStorage");
 var import_node_events = require("node:events");
 var import_node_path3 = __toESM(require("node:path"), 1);
 var monotonicUlid2 = monotonicFactory(() => Math.random());
+var RunStreamsSchema = external_exports.object({
+    streams: external_exports.array(external_exports.string())
+});
 function serializeChunk(chunk) {
     const eofByte = Buffer.from([
         chunk.eof ? 1 : 0
@@ -42205,10 +42176,31 @@ function deserializeChunk(serialized) {
 __name(deserializeChunk, "deserializeChunk");
 function createStreamer(basedir) {
     const streamEmitter = new import_node_events.EventEmitter();
+    const registeredStreams = /* @__PURE__ */ new Set();
+    async function registerStreamForRun(runId, streamName) {
+        const cacheKey = `${runId}:${streamName}`;
+        if (registeredStreams.has(cacheKey)) {
+            return;
+        }
+        const runStreamsPath = import_node_path3.default.join(basedir, "streams", "runs", `${runId}.json`);
+        const existing = await readJSON(runStreamsPath, RunStreamsSchema);
+        const streams = existing?.streams ?? [];
+        if (!streams.includes(streamName)) {
+            streams.push(streamName);
+            await writeJSON(runStreamsPath, {
+                streams
+            }, {
+                overwrite: true
+            });
+        }
+        registeredStreams.add(cacheKey);
+    }
+    __name(registerStreamForRun, "registerStreamForRun");
     return {
         async writeToStream(name, _runId, chunk) {
-            await _runId;
-            const chunkId = `strm_${monotonicUlid2()}`;
+            const runId = await _runId;
+            await registerStreamForRun(runId, name);
+            const chunkId = `chnk_${monotonicUlid2()}`;
             let chunkBuffer;
             if (typeof chunk === "string") {
                 chunkBuffer = Buffer.from(new TextEncoder().encode(chunk));
@@ -42233,8 +42225,9 @@ function createStreamer(basedir) {
             });
         },
         async closeStream(name, _runId) {
-            await _runId;
-            const chunkId = `strm_${monotonicUlid2()}`;
+            const runId = await _runId;
+            await registerStreamForRun(runId, name);
+            const chunkId = `chnk_${monotonicUlid2()}`;
             const chunkPath = import_node_path3.default.join(basedir, "streams", "chunks", `${name}-${chunkId}.json`);
             await write(chunkPath, serializeChunk({
                 chunk: Buffer.from([]),
@@ -42245,30 +42238,9 @@ function createStreamer(basedir) {
             });
         },
         async listStreamsByRunId(runId) {
-            const chunksDir = import_node_path3.default.join(basedir, "streams", "chunks");
-            const files = await listJSONFiles(chunksDir);
-            const streamPrefix = runId.replace("wrun_", "strm_") + "_user";
-            const streamNames = /* @__PURE__ */ new Set();
-            for (const file2 of files) {
-                const lastDashIndex = file2.lastIndexOf("-strm_");
-                if (lastDashIndex === -1) {
-                    const parts = file2.split("-");
-                    if (parts.length >= 2) {
-                        parts.pop();
-                        const streamName = parts.join("-");
-                        if (streamName.startsWith(streamPrefix)) {
-                            streamNames.add(streamName);
-                        }
-                    }
-                }
-                else {
-                    const streamName = file2.substring(0, lastDashIndex);
-                    if (streamName.startsWith(streamPrefix)) {
-                        streamNames.add(streamName);
-                    }
-                }
-            }
-            return Array.from(streamNames);
+            const runStreamsPath = import_node_path3.default.join(basedir, "streams", "runs", `${runId}.json`);
+            const data = await readJSON(runStreamsPath, RunStreamsSchema);
+            return data?.streams ?? [];
         },
         async readFromStream(name, startIndex = 0) {
             const chunksDir = import_node_path3.default.join(basedir, "streams", "chunks");
@@ -42365,7 +42337,7 @@ __name(createLocalWorld, "createLocalWorld");
 var import_node_os = __toESM(require("node:os"), 1);
 var import_oidc2 = __toESM(require_dist(), 1);
 // ../world-vercel/dist/version.js
-var version2 = "4.0.1-beta.20";
+var version2 = "4.0.1-beta.22";
 // ../world-vercel/dist/utils.js
 var DEFAULT_RESOLVE_DATA_OPTION2 = "all";
 function dateToStringReplacer(_key, value) {
@@ -42467,36 +42439,36 @@ __name(getHttpConfig, "getHttpConfig");
 async function makeRequest({ endpoint, options = {}, config: config3 = {}, schema }) {
     const { baseUrl, headers } = await getHttpConfig(config3);
     headers.set("Content-Type", "application/json");
+    headers.set("X-Request-Time", Date.now().toString());
     const url2 = `${baseUrl}${endpoint}`;
-    const response = await fetch(url2, {
+    const request = new Request(url2, {
         ...options,
         headers
     });
+    const response = await fetch(request);
     if (!response.ok) {
         const errorData = await response.json().catch(() => ({}));
         if (process.env.DEBUG === "1") {
             const stringifiedHeaders = Array.from(headers.entries()).map(([key, value]) => `-H "${key}: ${value}"`).join(" ");
             console.error(`Failed to fetch, reproduce with:
-curl -X ${options.method} ${stringifiedHeaders} "${url2}"`);
+curl -X ${request.method} ${stringifiedHeaders} "${url2}"`);
         }
-        throw new WorkflowAPIError(errorData.message || `${options.method ?? "GET"} ${endpoint} -> HTTP ${response.status}: ${response.statusText}`, {
+        throw new WorkflowAPIError(errorData.message || `${request.method} ${endpoint} -> HTTP ${response.status}: ${response.statusText}`, {
             url: url2,
             status: response.status,
             code: errorData.code
         });
     }
+    const text = await response.text();
     try {
-        const text = await response.text();
         return schema.parse(JSON.parse(text));
     }
     catch (error45) {
-        if (error45 instanceof ZodError) {
-            throw new WorkflowAPIError(`Failed to parse server response for ${options.method ?? "GET"} ${endpoint}: ${error45.message}`, {
-                url: url2,
-                cause: error45
-            });
-        }
-        throw new WorkflowAPIError(`Failed to parse server response for ${options.method ?? "GET"} ${endpoint}`, {
+        throw new WorkflowAPIError(`Failed to parse server response for ${request.method} ${endpoint}:
+
+${error45}
+
+Response body: ${text}`, {
             url: url2,
             cause: error45
         });
@@ -42506,9 +42478,19 @@ __name(makeRequest, "makeRequest");
 // ../world-vercel/dist/queue.js
 var MessageWrapper = object({
     payload: QueuePayloadSchema,
-    queueName: ValidQueueName
-});
-var VERCEL_QUEUE_MAX_VISIBILITY = 39600;
+    queueName: ValidQueueName,
+    /**
+     * The deployment ID to use when re-enqueueing the message.
+     * This ensures the message is processed by the same deployment.
+     */
+    deploymentId: string2().optional()
+});
+var VERCEL_QUEUE_MESSAGE_LIFETIME = Number(process.env.VERCEL_QUEUE_MESSAGE_LIFETIME || 86400
+// 24 hours in seconds
+);
+var MESSAGE_LIFETIME_BUFFER = Number(process.env.VERCEL_QUEUE_MESSAGE_LIFETIME_BUFFER || 3600
+// 1 hour buffer before lifetime expires
+);
 function createQueue2(config3) {
     const { baseUrl, usingProxy } = getHttpUrl(config3);
     const headers = getHeaders(config3);
@@ -42518,15 +42500,17 @@ function createQueue2(config3) {
         token: usingProxy ? config3?.token : void 0,
         headers: Object.fromEntries(headers.entries())
     });
-    const queue = /* @__PURE__ */ __name(async (queueName, x, opts) => {
+    const queue = /* @__PURE__ */ __name(async (queueName, payload, opts) => {
         const hasEncoder = typeof MessageWrapper.encode === "function";
         if (!hasEncoder) {
             console.warn("Using zod v3 compatibility mode for queue() calls - this may not work as expected");
         }
         const encoder = hasEncoder ? MessageWrapper.encode : (data) => data;
         const encoded = encoder({
-            payload: x,
-            queueName
+            payload,
+            queueName,
+            // Store deploymentId in the message so it can be preserved when re-enqueueing
+            deploymentId: opts?.deploymentId
         });
         const sanitizedQueueName = queueName.replace(/[^A-Za-z0-9-_]/g, "-");
         const { messageId } = await queueClient.send(sanitizedQueueName, encoded, opts);
@@ -42538,16 +42522,24 @@ function createQueue2(config3) {
         return queueClient.handleCallback({
             [`${prefix}*`]: {
                 default: /* @__PURE__ */ __name(async (body, meta) => {
-                    const { payload, queueName } = MessageWrapper.parse(body);
+                    const { payload, queueName, deploymentId } = MessageWrapper.parse(body);
                     const result = await handler(payload, {
                         queueName,
                         messageId: MessageId.parse(meta.messageId),
                         attempt: meta.deliveryCount
                     });
                     if (typeof result?.timeoutSeconds === "number") {
-                        const adjustedTimeoutSeconds = Math.min(result.timeoutSeconds, VERCEL_QUEUE_MAX_VISIBILITY);
-                        if (adjustedTimeoutSeconds !== result.timeoutSeconds) {
-                            result.timeoutSeconds = adjustedTimeoutSeconds;
+                        const now = Date.now();
+                        const messageAge = (now - meta.createdAt.getTime()) / 1e3;
+                        const maxAllowedTimeout = VERCEL_QUEUE_MESSAGE_LIFETIME - MESSAGE_LIFETIME_BUFFER - messageAge;
+                        if (maxAllowedTimeout <= 0) {
+                            await queue(queueName, payload, {
+                                deploymentId
+                            });
+                            return void 0;
+                        }
+                        else if (result.timeoutSeconds > maxAllowedTimeout) {
+                            result.timeoutSeconds = maxAllowedTimeout;
                         }
                     }
                     return result;
@@ -43204,11 +43196,13 @@ var WORKFLOW_CREATE_HOOK = Symbol.for("WORKFLOW_CREATE_HOOK");
 var WORKFLOW_SLEEP = Symbol.for("WORKFLOW_SLEEP");
 var WORKFLOW_CONTEXT = Symbol.for("WORKFLOW_CONTEXT");
 var WORKFLOW_GET_STREAM_ID = Symbol.for("WORKFLOW_GET_STREAM_ID");
+var STABLE_ULID = Symbol.for("WORKFLOW_STABLE_ULID");
 var STREAM_NAME_SYMBOL = Symbol.for("WORKFLOW_STREAM_NAME");
 var STREAM_TYPE_SYMBOL = Symbol.for("WORKFLOW_STREAM_TYPE");
 var BODY_INIT_SYMBOL = Symbol.for("BODY_INIT");
 var WEBHOOK_RESPONSE_WRITABLE = Symbol.for("WEBHOOK_RESPONSE_WRITABLE");
 // ../core/dist/serialization.js
+var defaultUlid = monotonicFactory();
 function formatSerializationError(context, error45) {
     const verb = context.includes("return value") ? "returning" : "passing";
     let message = `Failed to serialize ${context}`;
@@ -43465,7 +43459,8 @@ function getStepReducers(global2 = globalThis, ops, runId) {
                 if (!runId) {
                     throw new Error("ReadableStream cannot be serialized without a valid runId");
                 }
-                name = global2.crypto.randomUUID();
+                const streamId = (global2[STABLE_ULID] || defaultUlid)();
+                name = `strm_${streamId}`;
                 type = getStreamType(value);
                 const writable = new WorkflowServerWritableStream(name, runId);
                 if (type === "bytes") {
@@ -43490,7 +43485,8 @@ function getStepReducers(global2 = globalThis, ops, runId) {
                 if (!runId) {
                     throw new Error("WritableStream cannot be serialized without a valid runId");
                 }
-                name = global2.crypto.randomUUID();
+                const streamId = (global2[STABLE_ULID] || defaultUlid)();
+                name = `strm_${streamId}`;
                 ops.push(new WorkflowServerReadableStream(name).pipeThrough(getDeserializeStream(getStepRevivers(global2, ops, runId))).pipeTo(value));
             }
             return {
@@ -43703,6 +43699,8 @@ var WorkflowTracePropagated = SemanticConvention("workflow.trace.propagated");
 var WorkflowErrorName = SemanticConvention("workflow.error.name");
 var WorkflowErrorMessage = SemanticConvention("workflow.error.message");
 var WorkflowStepsCreated = SemanticConvention("workflow.steps.created");
+var WorkflowHooksCreated = SemanticConvention("workflow.hooks.created");
+var WorkflowWaitsCreated = SemanticConvention("workflow.waits.created");
 var StepName = SemanticConvention("step.name");
 var StepId = SemanticConvention("step.id");
 var StepAttempt = SemanticConvention("step.attempt");
@@ -44069,6 +44067,41 @@ async function writeEvent(writable, event, payload) {
 }
 __name(writeEvent, "writeEvent");
 registerStepFunction("step//workflows/hooks.ts//writeEvent", writeEvent);
+// workflows/addition.ts
+async function add(num, num2) {
+    return num + num2;
+}
+__name(add, "add");
+async function addition(num, num2) {
+    throw new Error("You attempted to execute workflow addition function directly. To start a workflow, use start(addition) from workflow/api");
+}
+__name(addition, "addition");
+addition.workflowId = "workflow//workflows/addition.ts//addition";
+registerStepFunction("step//workflows/addition.ts//add", add);
+// workflows/noop.ts
+var count = 0;
+async function noop(_i) {
+    count++;
+    return count;
+}
+__name(noop, "noop");
+async function brokenWf() {
+    throw new Error("You attempted to execute workflow brokenWf function directly. To start a workflow, use start(brokenWf) from workflow/api");
+}
+__name(brokenWf, "brokenWf");
+brokenWf.workflowId = "workflow//workflows/noop.ts//brokenWf";
+registerStepFunction("step//workflows/noop.ts//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.ts//nullByteWorkflow";
+registerStepFunction("step//workflows/null-byte.ts//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");
@@ -44096,19 +44129,6 @@ async function stepThatFails() {
 __name(stepThatFails, "stepThatFails");
 registerStepFunction("step//workflows/retriable-and-fatal.ts//stepThatThrowsRetryableError", stepThatThrowsRetryableError);
 registerStepFunction("step//workflows/retriable-and-fatal.ts//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.ts//nullByteWorkflow";
-registerStepFunction("step//workflows/null-byte.ts//nullByteStep", nullByteStep);
-// ../core/dist/runtime.js
-var import_functions4 = __toESM(require_functions(), 1);
 // ../core/dist/logger.js
 var import_debug = __toESM(require_src2(), 1);
 function createLogger(namespace) {
@@ -44141,6 +44161,47 @@ var runtimeLogger = createLogger("runtime");
 var webhookLogger = createLogger("webhook");
 var eventsLogger = createLogger("events");
 var adapterLogger = createLogger("adapter");
+// ../core/dist/runtime/helpers.js
+function withHealthCheck(handler) {
+    return async (req) => {
+        const url2 = new URL(req.url);
+        const isHealthCheck = url2.searchParams.has("__health");
+        if (isHealthCheck) {
+            return new Response(`Workflow DevKit "${url2.pathname}" endpoint is healthy`, {
+                status: 200,
+                headers: {
+                    "Content-Type": "text/plain"
+                }
+            });
+        }
+        return await handler(req);
+    };
+}
+__name(withHealthCheck, "withHealthCheck");
+async function queueMessage(world, ...args) {
+    const queueName = args[0];
+    await trace("queueMessage", {
+        attributes: QueueName(queueName),
+        kind: await getSpanKind("PRODUCER")
+    }, async (span) => {
+        const { messageId } = await world.queue(...args);
+        span?.setAttributes(QueueMessageId(messageId));
+    });
+}
+__name(queueMessage, "queueMessage");
+function getQueueOverhead(message) {
+    if (!message.requestedAt)
+        return;
+    try {
+        return QueueOverheadMs(Date.now() - message.requestedAt.getTime());
+    }
+    catch {
+        return;
+    }
+}
+__name(getQueueOverhead, "getQueueOverhead");
+// ../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
 var comma = ",".charCodeAt(0);
 var semicolon = ";".charCodeAt(0);
@@ -44179,25 +44240,10 @@ var EventConsumerResult;
 // ../core/dist/vm/index.js
 var import_seedrandom = __toESM(require_seedrandom2(), 1);
 // ../core/dist/runtime/start.js
-var import_functions3 = __toESM(require_functions(), 1);
-// ../core/dist/runtime.js
+var import_functions4 = __toESM(require_functions(), 1);
+// ../core/dist/runtime/step-handler.js
+var import_functions5 = __toESM(require_functions(), 1);
 var DEFAULT_STEP_MAX_RETRIES = 3;
-function withHealthCheck(handler) {
-    return async (req) => {
-        const url2 = new URL(req.url);
-        const isHealthCheck = url2.searchParams.has("__health");
-        if (isHealthCheck) {
-            return new Response(`Workflow DevKit "${url2.pathname}" endpoint is healthy`, {
-                status: 200,
-                headers: {
-                    "Content-Type": "text/plain"
-                }
-            });
-        }
-        return await handler(req);
-    };
-}
-__name(withHealthCheck, "withHealthCheck");
 var stepHandler = getWorldHandlers().createQueueHandler("__wkf_step_", async (message_, metadata) => {
     const { workflowName, workflowRunId, workflowStartedAt, stepId, traceCarrier: traceContext, requestedAt } = StepInvokePayloadSchema.parse(message_);
     const spanLinks = await linkToCurrentContext();
@@ -44348,7 +44394,7 @@ var stepHandler = getWorldHandlers().createQueueHandler("__wkf_step_", async (me
                     closureVars: hydratedInput.closureVars
                 }, () => stepFn.apply(null, args));
                 result = dehydrateStepReturnValue(result, ops, workflowRunId);
-                (0, import_functions4.waitUntil)(Promise.all(ops).catch((err) => {
+                (0, import_functions5.waitUntil)(Promise.all(ops).catch((err) => {
                     const isAbortError = err?.name === "AbortError" || err?.name === "ResponseAborted";
                     if (!isAbortError)
                         throw err;
@@ -44492,28 +44538,6 @@ Bubbling up error to parent workflow`);
     });
 });
 var stepEntrypoint = /* @__PURE__ */ withHealthCheck(stepHandler);
-async function queueMessage(world, ...args) {
-    const queueName = args[0];
-    await trace("queueMessage", {
-        attributes: QueueName(queueName),
-        kind: await getSpanKind("PRODUCER")
-    }, async (span) => {
-        const { messageId } = await world.queue(...args);
-        span?.setAttributes(QueueMessageId(messageId));
-    });
-}
-__name(queueMessage, "queueMessage");
-function getQueueOverhead(message) {
-    if (!message.requestedAt)
-        return;
-    try {
-        return QueueOverheadMs(Date.now() - message.requestedAt.getTime());
-    }
-    catch {
-        return;
-    }
-}
-__name(getQueueOverhead, "getQueueOverhead");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
     POST