@workflow/world-testing 4.0.1-beta.32 → 4.0.1-beta.34

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,19 +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/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";
@@ -25209,6 +25196,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");
@@ -25396,8 +25546,8 @@ async function getPort() {
     return ports[0];
 }
 __name(getPort, "getPort");
-var PROBE_TIMEOUT_MS = 1e3;
-var PROBE_ENDPOINT = "/.well-known/workflow/v1/flow";
+var PROBE_TIMEOUT_MS = 500;
+var PROBE_ENDPOINT = "/.well-known/workflow/v1/flow?__health";
 async function probePort(port, options = {}) {
     const { endpoint = PROBE_ENDPOINT, timeout = PROBE_TIMEOUT_MS } = options;
     const controller = new AbortController();
@@ -25407,7 +25557,7 @@ async function probePort(port, options = {}) {
             method: "HEAD",
             signal: controller.signal
         });
-        return response.status !== 404;
+        return response.status === 200;
     }
     catch {
         return false;
@@ -41182,170 +41332,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 +41643,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 +41747,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 +42163,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 +42187,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 +42236,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 +42249,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 +42348,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.19";
+var version2 = "4.0.1-beta.21";
 // ../world-vercel/dist/utils.js
 var DEFAULT_RESOLVE_DATA_OPTION2 = "all";
 function dateToStringReplacer(_key, value) {
@@ -42423,7 +42406,12 @@ var getHttpUrl = /* @__PURE__ */ __name((config3) => {
     const projectConfig = config3?.projectConfig;
     const defaultUrl = "https://vercel-workflow.com/api";
     const defaultProxyUrl = "https://api.vercel.com/v1/workflow";
-    const usingProxy = Boolean(config3?.baseUrl || projectConfig?.projectId && projectConfig?.teamId);
+    const usingProxy = (
+    // Skipping proxy is specifically used for e2e testing. Normally, we assume calls from
+    // CLI and web UI are not running inside the Vercel runtime environment, and so need to
+    // use the proxy for authentication. However, during e2e tests, this is not the case,
+    // so we allow skipping the proxy.
+    !config3?.skipProxy && Boolean(config3?.baseUrl || projectConfig?.projectId && projectConfig?.teamId));
     const baseUrl = config3?.baseUrl || (usingProxy ? defaultProxyUrl : defaultUrl);
     return {
         baseUrl,
@@ -42462,6 +42450,7 @@ __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, {
         ...options,
@@ -43149,7 +43138,8 @@ var createWorld = /* @__PURE__ */ __name(() => {
     const targetWorld = process.env.WORKFLOW_TARGET_WORLD || defaultWorld();
     if (targetWorld === "vercel") {
         return createVercelWorld({
-            baseUrl: process.env.WORKFLOW_VERCEL_PROXY_URL,
+            baseUrl: process.env.WORKFLOW_VERCEL_BACKEND_URL,
+            skipProxy: process.env.WORKFLOW_VERCEL_SKIP_PROXY === "true",
             token: process.env.WORKFLOW_VERCEL_AUTH_TOKEN,
             projectConfig: {
                 environment: process.env.WORKFLOW_VERCEL_ENV,
@@ -43198,11 +43188,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}`;
@@ -43459,7 +43451,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") {
@@ -43484,7 +43477,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 {
@@ -43697,6 +43691,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");
@@ -44039,6 +44035,43 @@ async function fetch2(...args) {
 }
 __name(fetch2, "fetch");
 registerStepFunction("step//workflow/dist/stdlib.js//fetch", fetch2);
+// workflows/hooks.ts
+var Hook = defineHook({
+    schema: object({
+        data: string2(),
+        done: boolean2().optional(),
+        metadata: unknown()
+    })
+});
+async function collectWithHook(token, customData) {
+    throw new Error("You attempted to execute workflow collectWithHook function directly. To start a workflow, use start(collectWithHook) from workflow/api");
+}
+__name(collectWithHook, "collectWithHook");
+collectWithHook.workflowId = "workflow//workflows/hooks.ts//collectWithHook";
+async function writeEvent(writable, event, payload) {
+    console.log("writing event", event, payload);
+    const writer = writable.getWriter();
+    await writer.write(new TextEncoder().encode(`${JSON.stringify({
+        event,
+        payload
+    })}\r
+`));
+}
+__name(writeEvent, "writeEvent");
+registerStepFunction("step//workflows/hooks.ts//writeEvent", writeEvent);
+// 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/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");
@@ -44077,32 +44110,6 @@ async function addition(num, num2) {
 __name(addition, "addition");
 addition.workflowId = "workflow//workflows/addition.ts//addition";
 registerStepFunction("step//workflows/addition.ts//add", add);
-// workflows/hooks.ts
-var Hook = defineHook({
-    schema: object({
-        data: string2(),
-        done: boolean2().optional(),
-        metadata: unknown()
-    })
-});
-async function collectWithHook(token, customData) {
-    throw new Error("You attempted to execute workflow collectWithHook function directly. To start a workflow, use start(collectWithHook) from workflow/api");
-}
-__name(collectWithHook, "collectWithHook");
-collectWithHook.workflowId = "workflow//workflows/hooks.ts//collectWithHook";
-async function writeEvent(writable, event, payload) {
-    console.log("writing event", event, payload);
-    const writer = writable.getWriter();
-    await writer.write(new TextEncoder().encode(`${JSON.stringify({
-        event,
-        payload
-    })}\r
-`));
-}
-__name(writeEvent, "writeEvent");
-registerStepFunction("step//workflows/hooks.ts//writeEvent", writeEvent);
-// ../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) {
@@ -44135,6 +44142,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);
@@ -44173,10 +44221,11 @@ 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;
-var stepEntrypoint = /* @__PURE__ */ getWorldHandlers().createQueueHandler("__wkf_step_", async (message_, metadata) => {
+var stepHandler = getWorldHandlers().createQueueHandler("__wkf_step_", async (message_, metadata) => {
     const { workflowName, workflowRunId, workflowStartedAt, stepId, traceCarrier: traceContext, requestedAt } = StepInvokePayloadSchema.parse(message_);
     const spanLinks = await linkToCurrentContext();
     return await withTraceContext(traceContext, async () => {
@@ -44326,7 +44375,7 @@ var stepEntrypoint = /* @__PURE__ */ getWorldHandlers().createQueueHandler("__wk
                     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;
@@ -44469,28 +44518,7 @@ Bubbling up error to parent workflow`);
         });
     });
 });
-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");
+var stepEntrypoint = /* @__PURE__ */ withHealthCheck(stepHandler);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
     POST