@workflow/world-testing 4.0.1-beta.21 → 4.0.1-beta.23

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

@@ -1,5 +1,23 @@
 {
     "steps": {
+        "workflows/addition.ts": {
+            "add": {
+                "stepId": "step//workflows/addition.ts//add"
+            }
+        },
+        "workflows/null-byte.ts": {
+            "nullByteStep": {
+                "stepId": "step//workflows/null-byte.ts//nullByteStep"
+            }
+        },
+        "workflows/retriable-and-fatal.ts": {
+            "stepThatFails": {
+                "stepId": "step//workflows/retriable-and-fatal.ts//stepThatFails"
+            },
+            "stepThatThrowsRetryableError": {
+                "stepId": "step//workflows/retriable-and-fatal.ts//stepThatThrowsRetryableError"
+            }
+        },
         "workflow/dist/internal/builtins.js": {
             "__builtin_response_array_buffer": {
                 "stepId": "__builtin_response_array_buffer"
@@ -11,51 +29,33 @@
                 "stepId": "__builtin_response_text"
             }
         },
-        "workflows/null-byte.ts": {
-            "nullByteStep": {
-                "stepId": "step//workflows/null-byte.ts//nullByteStep"
-            }
-        },
-        "workflows/addition.ts": {
-            "add": {
-                "stepId": "step//workflows/addition.ts//add"
-            }
-        },
         "workflow/dist/stdlib.js": {
             "fetch": {
                 "stepId": "step//workflow/dist/stdlib.js//fetch"
             }
         },
-        "workflows/noop.ts": {
-            "noop": {
-                "stepId": "step//workflows/noop.ts//noop"
-            }
-        },
-        "workflows/retriable-and-fatal.ts": {
-            "stepThatFails": {
-                "stepId": "step//workflows/retriable-and-fatal.ts//stepThatFails"
-            },
-            "stepThatThrowsRetryableError": {
-                "stepId": "step//workflows/retriable-and-fatal.ts//stepThatThrowsRetryableError"
-            }
-        },
         "workflows/hooks.ts": {
             "writeEvent": {
                 "stepId": "step//workflows/hooks.ts//writeEvent"
             }
+        },
+        "workflows/noop.ts": {
+            "noop": {
+                "stepId": "step//workflows/noop.ts//noop"
+            }
         }
     },
     "workflows": {
+        "workflows/null-byte.ts": {
+            "nullByteWorkflow": {
+                "workflowId": "workflow//workflows/null-byte.ts//nullByteWorkflow"
+            }
+        },
         "workflows/addition.ts": {
             "addition": {
                 "workflowId": "workflow//workflows/addition.ts//addition"
             }
         },
-        "workflows/hooks.ts": {
-            "collectWithHook": {
-                "workflowId": "workflow//workflows/hooks.ts//collectWithHook"
-            }
-        },
         "workflows/noop.ts": {
             "brokenWf": {
                 "workflowId": "workflow//workflows/noop.ts//brokenWf"
@@ -66,9 +66,9 @@
                 "workflowId": "workflow//workflows/retriable-and-fatal.ts//retryableAndFatalErrorWorkflow"
             }
         },
-        "workflows/null-byte.ts": {
-            "nullByteWorkflow": {
-                "workflowId": "workflow//workflows/null-byte.ts//nullByteWorkflow"
+        "workflows/hooks.ts": {
+            "collectWithHook": {
+                "workflowId": "workflow//workflows/hooks.ts//collectWithHook"
             }
         }
     }

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

@@ -20591,6 +20591,194 @@ var require_undici = __commonJS({
         module2.exports.EventSource = EventSource;
     }
 });
+// ../../node_modules/.pnpm/async-sema@3.1.1/node_modules/async-sema/lib/index.js
+var require_lib = __commonJS({
+    "../../node_modules/.pnpm/async-sema@3.1.1/node_modules/async-sema/lib/index.js"(exports2) {
+        "use strict";
+        var __importDefault = exports2 && exports2.__importDefault || function (mod) {
+            return mod && mod.__esModule ? mod : {
+                "default": mod
+            };
+        };
+        Object.defineProperty(exports2, "__esModule", {
+            value: true
+        });
+        exports2.RateLimit = exports2.Sema = void 0;
+        var events_1 = __importDefault(require("events"));
+        function arrayMove(src, srcIndex, dst, dstIndex, len) {
+            for (let j = 0; j < len; ++j) {
+                dst[j + dstIndex] = src[j + srcIndex];
+                src[j + srcIndex] = void 0;
+            }
+        }
+        __name(arrayMove, "arrayMove");
+        function pow2AtLeast(n2) {
+            n2 = n2 >>> 0;
+            n2 = n2 - 1;
+            n2 = n2 | n2 >> 1;
+            n2 = n2 | n2 >> 2;
+            n2 = n2 | n2 >> 4;
+            n2 = n2 | n2 >> 8;
+            n2 = n2 | n2 >> 16;
+            return n2 + 1;
+        }
+        __name(pow2AtLeast, "pow2AtLeast");
+        function getCapacity(capacity) {
+            return pow2AtLeast(Math.min(Math.max(16, capacity), 1073741824));
+        }
+        __name(getCapacity, "getCapacity");
+        var Deque = class {
+            static {
+                __name(this, "Deque");
+            }
+            constructor(capacity) {
+                this._capacity = getCapacity(capacity);
+                this._length = 0;
+                this._front = 0;
+                this.arr = [];
+            }
+            push(item) {
+                const length = this._length;
+                this.checkCapacity(length + 1);
+                const i2 = this._front + length & this._capacity - 1;
+                this.arr[i2] = item;
+                this._length = length + 1;
+                return length + 1;
+            }
+            pop() {
+                const length = this._length;
+                if (length === 0) {
+                    return void 0;
+                }
+                const i2 = this._front + length - 1 & this._capacity - 1;
+                const ret = this.arr[i2];
+                this.arr[i2] = void 0;
+                this._length = length - 1;
+                return ret;
+            }
+            shift() {
+                const length = this._length;
+                if (length === 0) {
+                    return void 0;
+                }
+                const front = this._front;
+                const ret = this.arr[front];
+                this.arr[front] = void 0;
+                this._front = front + 1 & this._capacity - 1;
+                this._length = length - 1;
+                return ret;
+            }
+            get length() {
+                return this._length;
+            }
+            checkCapacity(size) {
+                if (this._capacity < size) {
+                    this.resizeTo(getCapacity(this._capacity * 1.5 + 16));
+                }
+            }
+            resizeTo(capacity) {
+                const oldCapacity = this._capacity;
+                this._capacity = capacity;
+                const front = this._front;
+                const length = this._length;
+                if (front + length > oldCapacity) {
+                    const moveItemsCount = front + length & oldCapacity - 1;
+                    arrayMove(this.arr, 0, this.arr, oldCapacity, moveItemsCount);
+                }
+            }
+        };
+        var ReleaseEmitter = class extends events_1.default {
+            static {
+                __name(this, "ReleaseEmitter");
+            }
+        };
+        function isFn(x) {
+            return typeof x === "function";
+        }
+        __name(isFn, "isFn");
+        function defaultInit() {
+            return "1";
+        }
+        __name(defaultInit, "defaultInit");
+        var Sema2 = class {
+            static {
+                __name(this, "Sema");
+            }
+            constructor(nr, { initFn = defaultInit, pauseFn, resumeFn, capacity = 10 } = {}) {
+                if (isFn(pauseFn) !== isFn(resumeFn)) {
+                    throw new Error("pauseFn and resumeFn must be both set for pausing");
+                }
+                this.nrTokens = nr;
+                this.free = new Deque(nr);
+                this.waiting = new Deque(capacity);
+                this.releaseEmitter = new ReleaseEmitter();
+                this.noTokens = initFn === defaultInit;
+                this.pauseFn = pauseFn;
+                this.resumeFn = resumeFn;
+                this.paused = false;
+                this.releaseEmitter.on("release", (token) => {
+                    const p = this.waiting.shift();
+                    if (p) {
+                        p.resolve(token);
+                    }
+                    else {
+                        if (this.resumeFn && this.paused) {
+                            this.paused = false;
+                            this.resumeFn();
+                        }
+                        this.free.push(token);
+                    }
+                });
+                for (let i2 = 0; i2 < nr; i2++) {
+                    this.free.push(initFn());
+                }
+            }
+            tryAcquire() {
+                return this.free.pop();
+            }
+            async acquire() {
+                let token = this.tryAcquire();
+                if (token !== void 0) {
+                    return token;
+                }
+                return new Promise((resolve2, reject) => {
+                    if (this.pauseFn && !this.paused) {
+                        this.paused = true;
+                        this.pauseFn();
+                    }
+                    this.waiting.push({
+                        resolve: resolve2,
+                        reject
+                    });
+                });
+            }
+            release(token) {
+                this.releaseEmitter.emit("release", this.noTokens ? "1" : token);
+            }
+            drain() {
+                const a2 = new Array(this.nrTokens);
+                for (let i2 = 0; i2 < this.nrTokens; i2++) {
+                    a2[i2] = this.acquire();
+                }
+                return Promise.all(a2);
+            }
+            nrWaiting() {
+                return this.waiting.length;
+            }
+        };
+        exports2.Sema = Sema2;
+        function RateLimit(rps, { timeUnit = 1e3, uniformDistribution = false } = {}) {
+            const sema = new Sema2(uniformDistribution ? 1 : rps);
+            const delay = uniformDistribution ? timeUnit / rps : timeUnit;
+            return /* @__PURE__ */ __name(async function rl() {
+                await sema.acquire();
+                setTimeout(() => sema.release(), delay);
+            }, "rl");
+        }
+        __name(RateLimit, "RateLimit");
+        exports2.RateLimit = RateLimit;
+    }
+});
 // ../../node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/src/platform/node/globalThis.js
 var require_globalThis = __commonJS({
     "../../node_modules/.pnpm/@opentelemetry+api@1.9.0/node_modules/@opentelemetry/api/build/src/platform/node/globalThis.js"(exports2) {
@@ -23982,6 +24170,9 @@ __export(virtual_entry_exports, {
     POST: () => stepEntrypoint
 });
 module.exports = __toCommonJS(virtual_entry_exports);
+// ../core/dist/step/context-storage.js
+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 registerStepFunction(stepId, stepFn) {
@@ -24008,12 +24199,14 @@ __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/null-byte.ts
-async function nullByteStep() {
-    return "null byte \0";
+// workflows/noop.ts
+var count = 0;
+async function noop(_i) {
+    count++;
+    return count;
 }
-__name(nullByteStep, "nullByteStep");
-registerStepFunction("step//workflows/null-byte.ts//nullByteStep", nullByteStep);
+__name(noop, "noop");
+registerStepFunction("step//workflows/noop.ts//noop", noop);
 // ../utils/dist/index.js
 var import_ms = __toESM(require_ms(), 1);
 function once(fn) {
@@ -26571,13 +26764,13 @@ var handleSendStrict = /* @__PURE__ */ __name(({ anyProcess, channel, isSubproce
     const ipcEmitter = getIpcEmitter(anyProcess, channel, isSubprocess);
     const hasListeners = hasMessageListeners(anyProcess, ipcEmitter);
     return {
-        id: count++,
+        id: count2++,
         type: REQUEST_TYPE,
         message,
         hasListeners
     };
 }, "handleSendStrict");
-var count = 0n;
+var count2 = 0n;
 var validateStrictDeadlock = /* @__PURE__ */ __name((outgoingMessages, wrappedMessage) => {
     if (wrappedMessage?.type !== REQUEST_TYPE || wrappedMessage.hasListeners) {
         return;
@@ -27438,7 +27631,7 @@ var MaxBufferError = class extends Error {
 };
 // ../../node_modules/.pnpm/get-stream@9.0.1/node_modules/get-stream/source/utils.js
 var identity2 = /* @__PURE__ */ __name((value) => value, "identity");
-var noop = /* @__PURE__ */ __name(() => void 0, "noop");
+var noop2 = /* @__PURE__ */ __name(() => void 0, "noop");
 var getContentsProperty = /* @__PURE__ */ __name(({ contents }) => contents, "getContentsProperty");
 var throwObjectStream = /* @__PURE__ */ __name((chunk) => {
     throw new Error(`Streams in object mode are not supported: ${String(chunk)}`);
@@ -27468,9 +27661,9 @@ var arrayMethods = {
         others: identity2
     },
     getSize: increment,
-    truncateChunk: noop,
+    truncateChunk: noop2,
     addChunk: addArrayChunk,
-    getFinalChunk: noop,
+    getFinalChunk: noop2,
     finalize: getContentsProperty
 };
 // ../../node_modules/.pnpm/get-stream@9.0.1/node_modules/get-stream/source/array-buffer.js
@@ -27527,7 +27720,7 @@ var arrayBufferMethods = {
     getSize: getLengthProperty,
     truncateChunk: truncateArrayBufferChunk,
     addChunk: addArrayBufferChunk,
-    getFinalChunk: noop,
+    getFinalChunk: noop2,
     finalize: finalizeArrayBuffer
 };
 // ../../node_modules/.pnpm/get-stream@9.0.1/node_modules/get-stream/source/string.js
@@ -30194,11 +30387,11 @@ var abortStream = /* @__PURE__ */ __name((stream) => {
 }, "abortStream");
 var errorStream = /* @__PURE__ */ __name((stream, error45) => {
     if (!stream.destroyed) {
-        stream.once("error", noop2);
+        stream.once("error", noop3);
         stream.destroy(error45);
     }
 }, "errorStream");
-var noop2 = /* @__PURE__ */ __name(() => {
+var noop3 = /* @__PURE__ */ __name(() => {
 }, "noop");
 var updateMaxListeners = /* @__PURE__ */ __name((passThroughStream, increment2) => {
     const maxListeners = passThroughStream.getMaxListeners();
@@ -47898,13 +48091,17 @@ function monotonicFactory(prng) {
 __name(monotonicFactory, "monotonicFactory");
 // ../world-local/dist/queue.js
 var import_undici = __toESM(require_undici(), 1);
+var import_async_sema = __toESM(require_lib(), 1);
 var LOCAL_QUEUE_MAX_VISIBILITY = parseInt(process.env.WORKFLOW_LOCAL_QUEUE_MAX_VISIBILITY ?? "0", 10) || Infinity;
+var DEFAULT_CONCURRENCY_LIMIT = 20;
+var WORKFLOW_LOCAL_QUEUE_CONCURRENCY = parseInt(process.env.WORKFLOW_LOCAL_QUEUE_CONCURRENCY ?? "0", 10) || DEFAULT_CONCURRENCY_LIMIT;
 var httpAgent = new import_undici.Agent({
     headersTimeout: 0
 });
 function createQueue(config3) {
     const transport = new JsonTransport();
     const generateId = monotonicFactory();
+    const semaphore = new import_async_sema.Sema(WORKFLOW_LOCAL_QUEUE_CONCURRENCY);
     const inflightMessages = /* @__PURE__ */ new Map();
     const queue = /* @__PURE__ */ __name(async (queueName, message, opts) => {
         const cleanup = [];
@@ -47936,46 +48133,56 @@ function createQueue(config3) {
             });
         }
         (async () => {
-            let defaultRetriesLeft = 3;
-            const baseUrl = await resolveBaseUrl(config3);
-            for (let attempt = 0; defaultRetriesLeft > 0; attempt++) {
-                defaultRetriesLeft--;
-                const response = await fetch(`${baseUrl}/.well-known/workflow/v1/${pathname}`, {
-                    method: "POST",
-                    duplex: "half",
-                    // @ts-expect-error undici type differences
-                    dispatcher: httpAgent,
-                    headers: {
-                        "content-type": "application/json",
-                        "x-vqs-queue-name": queueName,
-                        "x-vqs-message-id": messageId,
-                        "x-vqs-message-attempt": String(attempt + 1)
-                    },
-                    body
-                });
-                if (response.ok) {
-                    return;
-                }
-                const text = await response.text();
-                if (response.status === 503) {
-                    try {
-                        const timeoutSeconds = Number(JSON.parse(text).timeoutSeconds);
-                        await (0, import_promises12.setTimeout)(timeoutSeconds * 1e3);
-                        defaultRetriesLeft++;
-                        continue;
+            const token = semaphore.tryAcquire();
+            if (!token) {
+                console.warn(`[world-local]: concurrency limit (${WORKFLOW_LOCAL_QUEUE_CONCURRENCY}) reached, waiting for queue to free up`);
+                await semaphore.acquire();
+            }
+            try {
+                let defaultRetriesLeft = 3;
+                const baseUrl = await resolveBaseUrl(config3);
+                for (let attempt = 0; defaultRetriesLeft > 0; attempt++) {
+                    defaultRetriesLeft--;
+                    const response = await fetch(`${baseUrl}/.well-known/workflow/v1/${pathname}`, {
+                        method: "POST",
+                        duplex: "half",
+                        // @ts-expect-error undici type differences
+                        dispatcher: httpAgent,
+                        headers: {
+                            "content-type": "application/json",
+                            "x-vqs-queue-name": queueName,
+                            "x-vqs-message-id": messageId,
+                            "x-vqs-message-attempt": String(attempt + 1)
+                        },
+                        body
+                    });
+                    if (response.ok) {
+                        return;
                     }
-                    catch {
+                    const text = await response.text();
+                    if (response.status === 503) {
+                        try {
+                            const timeoutSeconds = Number(JSON.parse(text).timeoutSeconds);
+                            await (0, import_promises12.setTimeout)(timeoutSeconds * 1e3);
+                            defaultRetriesLeft++;
+                            continue;
+                        }
+                        catch {
+                        }
                     }
+                    console.error(`[embedded world] Failed to queue message`, {
+                        queueName,
+                        text,
+                        status: response.status,
+                        headers: Object.fromEntries(response.headers.entries()),
+                        body: body.toString()
+                    });
                 }
-                console.error(`[embedded world] Failed to queue message`, {
-                    queueName,
-                    text,
-                    status: response.status,
-                    headers: Object.fromEntries(response.headers.entries()),
-                    body: body.toString()
-                });
+                console.error(`[embedded world] Reached max retries of embedded world queue implementation`);
+            }
+            finally {
+                semaphore.release();
             }
-            console.error(`[embedded world] Reached max retries of embedded world queue implementation`);
         })().catch((err) => {
             const isAbortError2 = err?.name === "AbortError" || err?.name === "ResponseAborted";
             if (!isAbortError2) {
@@ -48864,7 +49071,7 @@ __name(createEmbeddedWorld, "createEmbeddedWorld");
 var import_node_os4 = __toESM(require("node:os"), 1);
 var import_oidc2 = __toESM(require_dist(), 1);
 // ../world-vercel/dist/version.js
-var version2 = "4.0.1-beta.11";
+var version2 = "4.0.1-beta.13";
 // ../world-vercel/dist/utils.js
 var DEFAULT_RESOLVE_DATA_OPTION2 = "all";
 function dateToStringReplacer(_key, value) {
@@ -49022,7 +49229,7 @@ function createQueue2(config3) {
     const queue = /* @__PURE__ */ __name(async (queueName, x, opts) => {
         const hasEncoder = typeof MessageWrapper.encode === "function";
         if (!hasEncoder) {
-            throw new Error("zod v3 compatibility mode: MessageWrapper.encode is not a function");
+            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({
@@ -49897,7 +50104,19 @@ function getCommonReducers(global3 = globalThis) {
             if (typeof value !== "function")
                 return false;
             const stepId = value.stepId;
-            return typeof stepId === "string" ? stepId : false;
+            if (typeof stepId !== "string")
+                return false;
+            const closureVarsFn = value.__closureVarsFn;
+            if (closureVarsFn && typeof closureVarsFn === "function") {
+                const closureVars = closureVarsFn();
+                return {
+                    stepId,
+                    closureVars
+                };
+            }
+            return {
+                stepId
+            };
         }, "StepFunction"),
         URL: /* @__PURE__ */ __name((value) => value instanceof global3.URL && value.href, "URL"),
         URLSearchParams: /* @__PURE__ */ __name((value) => {
@@ -50017,9 +50236,37 @@ function getCommonRevivers(global3 = globalThis) {
         RegExp: /* @__PURE__ */ __name((value) => new global3.RegExp(value.source, value.flags), "RegExp"),
         Set: /* @__PURE__ */ __name((value) => new global3.Set(value), "Set"),
         StepFunction: /* @__PURE__ */ __name((value) => {
-            const stepFn = getStepFunction(value);
+            const stepId = value.stepId;
+            const closureVars = value.closureVars;
+            const stepFn = getStepFunction(stepId);
             if (!stepFn) {
-                throw new Error(`Step function "${value}" not found. Make sure the step function is registered.`);
+                throw new Error(`Step function "${stepId}" not found. Make sure the step function is registered.`);
+            }
+            if (closureVars) {
+                const wrappedStepFn = /* @__PURE__ */ __name((...args) => {
+                    const currentContext = contextStorage.getStore();
+                    if (!currentContext) {
+                        throw new Error("Cannot call step function with closure variables outside step context");
+                    }
+                    const newContext = {
+                        ...currentContext,
+                        closureVars
+                    };
+                    return contextStorage.run(newContext, () => stepFn(...args));
+                }, "wrappedStepFn");
+                Object.defineProperty(wrappedStepFn, "name", {
+                    value: stepFn.name
+                });
+                Object.defineProperty(wrappedStepFn, "stepId", {
+                    value: stepId,
+                    writable: false,
+                    enumerable: false,
+                    configurable: false
+                });
+                if (stepFn.maxRetries !== void 0) {
+                    wrappedStepFn.maxRetries = stepFn.maxRetries;
+                }
+                return wrappedStepFn;
             }
             return stepFn;
         }, "StepFunction"),
@@ -50358,9 +50605,6 @@ function defineHook({ schema } = {}) {
     };
 }
 __name(defineHook, "defineHook");
-// ../core/dist/step/context-storage.js
-var import_node_async_hooks = require("node:async_hooks");
-var contextStorage = /* @__PURE__ */ new import_node_async_hooks.AsyncLocalStorage();
 // ../core/dist/step/get-step-metadata.js
 function getStepMetadata() {
     const ctx = contextStorage.getStore();
@@ -50401,6 +50645,12 @@ async function add(num, num2) {
 }
 __name(add, "add");
 registerStepFunction("step//workflows/addition.ts//add", add);
+// workflows/null-byte.ts
+async function nullByteStep() {
+    return "null byte \0";
+}
+__name(nullByteStep, "nullByteStep");
+registerStepFunction("step//workflows/null-byte.ts//nullByteStep", nullByteStep);
 // workflows/retriable-and-fatal.ts
 async function stepThatThrowsRetryableError() {
     const { attempt, stepStartedAt } = getStepMetadata();
@@ -50423,14 +50673,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/noop.ts
-var count2 = 0;
-async function noop3(_i) {
-    count2++;
-    return count2;
-}
-__name(noop3, "noop");
-registerStepFunction("step//workflows/noop.ts//noop", noop3);
 // ../core/dist/runtime.js
 var import_functions4 = __toESM(require_functions(), 1);
 // ../core/dist/logger.js
@@ -50596,7 +50838,8 @@ var stepEntrypoint = /* @__PURE__ */ getWorldHandlers().createQueueHandler("__wk
                     throw new WorkflowRuntimeError(`Step "${stepId}" has no "startedAt" timestamp`);
                 }
                 const ops = [];
-                const args = hydrateStepArguments(step.input, ops, workflowRunId);
+                const hydratedInput = hydrateStepArguments(step.input, ops, workflowRunId);
+                const args = hydratedInput.args;
                 span?.setAttributes({
                     ...StepArgumentsCount(args.length)
                 });
@@ -50613,8 +50856,9 @@ var stepEntrypoint = /* @__PURE__ */ getWorldHandlers().createQueueHandler("__wk
                         // solution only works for vercel + local worlds.
                         url: process.env.VERCEL_URL ? `https://${process.env.VERCEL_URL}` : `http://localhost:${port ?? 3e3}`
                     },
-                    ops
-                }, () => stepFn(...args));
+                    ops,
+                    closureVars: hydratedInput.closureVars
+                }, () => stepFn.apply(null, args));
                 result = dehydrateStepReturnValue(result, ops, workflowRunId);
                 (0, import_functions4.waitUntil)(Promise.all(ops).catch((err) => {
                     const isAbortError2 = err?.name === "AbortError" || err?.name === "ResponseAborted";