@workflow/world-testing 4.1.0-beta.58 → 4.1.0-beta.60

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

@@ -200,12 +200,12 @@ var require_headers = __commonJS({
         var POSTAL_CODE_HEADER_NAME = "x-vercel-ip-postal-code";
         var REQUEST_ID_HEADER_NAME = "x-vercel-id";
         var EMOJI_FLAG_UNICODE_STARTING_POSITION = 127397;
-        function getHeader(headers, key) {
+        function getHeader2(headers, key) {
             return headers.get(key) ?? void 0;
         }
-        __name(getHeader, "getHeader");
+        __name(getHeader2, "getHeader");
         function getHeaderWithDecode(request, key) {
-            const header = getHeader(request.headers, key);
+            const header = getHeader2(request.headers, key);
             return header ? decodeURIComponent(header) : void 0;
         }
         __name(getHeaderWithDecode, "getHeaderWithDecode");
@@ -218,7 +218,7 @@ var require_headers = __commonJS({
         __name(getFlag, "getFlag");
         function ipAddress2(input) {
             const headers = "headers" in input ? input.headers : input;
-            return getHeader(headers, IP_HEADER_NAME);
+            return getHeader2(headers, IP_HEADER_NAME);
         }
         __name(ipAddress2, "ipAddress");
         function getRegionFromRequestId(requestId) {
@@ -232,13 +232,13 @@ var require_headers = __commonJS({
             return {
                 // city name may be encoded to support multi-byte characters
                 city: getHeaderWithDecode(request, CITY_HEADER_NAME),
-                country: getHeader(request.headers, COUNTRY_HEADER_NAME),
-                flag: getFlag(getHeader(request.headers, COUNTRY_HEADER_NAME)),
-                countryRegion: getHeader(request.headers, REGION_HEADER_NAME),
-                region: getRegionFromRequestId(getHeader(request.headers, REQUEST_ID_HEADER_NAME)),
-                latitude: getHeader(request.headers, LATITUDE_HEADER_NAME),
-                longitude: getHeader(request.headers, LONGITUDE_HEADER_NAME),
-                postalCode: getHeader(request.headers, POSTAL_CODE_HEADER_NAME)
+                country: getHeader2(request.headers, COUNTRY_HEADER_NAME),
+                flag: getFlag(getHeader2(request.headers, COUNTRY_HEADER_NAME)),
+                countryRegion: getHeader2(request.headers, REGION_HEADER_NAME),
+                region: getRegionFromRequestId(getHeader2(request.headers, REQUEST_ID_HEADER_NAME)),
+                latitude: getHeader2(request.headers, LATITUDE_HEADER_NAME),
+                longitude: getHeader2(request.headers, LONGITUDE_HEADER_NAME),
+                postalCode: getHeader2(request.headers, POSTAL_CODE_HEADER_NAME)
             };
         }
         __name(geolocation2, "geolocation");
@@ -4182,7 +4182,7 @@ var require_token_util = __commonJS({
             getTokenPayload: /* @__PURE__ */ __name(() => getTokenPayload, "getTokenPayload"),
             getVercelCliToken: /* @__PURE__ */ __name(() => getVercelCliToken, "getVercelCliToken"),
             getVercelDataDir: /* @__PURE__ */ __name(() => getVercelDataDir, "getVercelDataDir"),
-            getVercelOidcToken: /* @__PURE__ */ __name(() => getVercelOidcToken4, "getVercelOidcToken"),
+            getVercelOidcToken: /* @__PURE__ */ __name(() => getVercelOidcToken6, "getVercelOidcToken"),
             isExpired: /* @__PURE__ */ __name(() => isExpired, "isExpired"),
             loadToken: /* @__PURE__ */ __name(() => loadToken, "loadToken"),
             saveToken: /* @__PURE__ */ __name(() => saveToken, "saveToken")
@@ -4217,7 +4217,7 @@ var require_token_util = __commonJS({
             return JSON.parse(token).token;
         }
         __name(getVercelCliToken, "getVercelCliToken");
-        async function getVercelOidcToken4(authToken, projectId, teamId) {
+        async function getVercelOidcToken6(authToken, projectId, teamId) {
             try {
                 const url2 = `https://api.vercel.com/v1/projects/${projectId}/token?source=vercel-oidc-refresh${teamId ? `&teamId=${teamId}` : ""}`;
                 const res = await fetch(url2, {
@@ -4237,7 +4237,7 @@ var require_token_util = __commonJS({
                 throw new import_token_error.VercelOidcTokenError(`Failed to refresh OIDC token`, e);
             }
         }
-        __name(getVercelOidcToken4, "getVercelOidcToken");
+        __name(getVercelOidcToken6, "getVercelOidcToken");
         function assertVercelOidcTokenResponse(res) {
             if (!res || typeof res !== "object") {
                 throw new TypeError("Expected an object");
@@ -4417,13 +4417,13 @@ var require_get_vercel_oidc_token = __commonJS({
         }), mod), "__toCommonJS");
         var get_vercel_oidc_token_exports = {};
         __export2(get_vercel_oidc_token_exports, {
-            getVercelOidcToken: /* @__PURE__ */ __name(() => getVercelOidcToken4, "getVercelOidcToken"),
+            getVercelOidcToken: /* @__PURE__ */ __name(() => getVercelOidcToken6, "getVercelOidcToken"),
             getVercelOidcTokenSync: /* @__PURE__ */ __name(() => getVercelOidcTokenSync2, "getVercelOidcTokenSync")
         });
         module2.exports = __toCommonJS2(get_vercel_oidc_token_exports);
         var import_get_context = require_get_context2();
         var import_token_error = require_token_error();
-        async function getVercelOidcToken4() {
+        async function getVercelOidcToken6() {
             let token = "";
             let err;
             try {
@@ -4451,7 +4451,7 @@ ${error45.message}`;
             }
             return token;
         }
-        __name(getVercelOidcToken4, "getVercelOidcToken");
+        __name(getVercelOidcToken6, "getVercelOidcToken");
         function getVercelOidcTokenSync2() {
             const token = (0, import_get_context.getContext)().headers?.["x-vercel-oidc-token"] ?? process.env.VERCEL_OIDC_TOKEN;
             if (!token) {
@@ -12180,7 +12180,7 @@ var require_client = __commonJS({
             return client[kPipelining] ?? client[kHTTPContext]?.defaultPipelining ?? 1;
         }
         __name(getPipelining, "getPipelining");
-        var Client2 = class extends DispatcherBase {
+        var Client = class extends DispatcherBase {
             static {
                 __name(this, "Client");
             }
@@ -12612,7 +12612,7 @@ var require_client = __commonJS({
             }
         }
         __name(_resume, "_resume");
-        module2.exports = Client2;
+        module2.exports = Client;
     }
 });
 // ../../node_modules/.pnpm/undici@6.22.0/node_modules/undici/lib/dispatcher/fixed-queue.js
@@ -12894,7 +12894,7 @@ var require_pool = __commonJS({
     "../../node_modules/.pnpm/undici@6.22.0/node_modules/undici/lib/dispatcher/pool.js"(exports2, module2) {
         "use strict";
         var { PoolBase, kClients, kNeedDrain, kAddClient, kGetDispatcher } = require_pool_base();
-        var Client2 = require_client();
+        var Client = require_client();
         var { InvalidArgumentError } = require_errors();
         var util = require_util();
         var { kUrl, kInterceptors } = require_symbols();
@@ -12903,7 +12903,7 @@ var require_pool = __commonJS({
         var kConnections = Symbol("connections");
         var kFactory = Symbol("factory");
         function defaultFactory(origin, opts) {
-            return new Client2(origin, opts);
+            return new Client(origin, opts);
         }
         __name(defaultFactory, "defaultFactory");
         var Pool = class extends PoolBase {
@@ -13121,7 +13121,7 @@ var require_agent = __commonJS({
         var { kClients, kRunning, kClose, kDestroy, kDispatch, kInterceptors } = require_symbols();
         var DispatcherBase = require_dispatcher_base();
         var Pool = require_pool();
-        var Client2 = require_client();
+        var Client = require_client();
         var util = require_util();
         var createRedirectInterceptor = require_redirect_interceptor();
         var kOnConnect = Symbol("onConnect");
@@ -13132,7 +13132,7 @@ var require_agent = __commonJS({
         var kFactory = Symbol("factory");
         var kOptions = Symbol("options");
         function defaultFactory(origin, opts) {
-            return opts && opts.connections === 1 ? new Client2(origin, opts) : new Pool(origin, opts);
+            return opts && opts.connections === 1 ? new Client(origin, opts) : new Pool(origin, opts);
         }
         __name(defaultFactory, "defaultFactory");
         var Agent2 = class extends DispatcherBase {
@@ -13248,7 +13248,7 @@ var require_proxy_agent = __commonJS({
         var DispatcherBase = require_dispatcher_base();
         var { InvalidArgumentError, RequestAbortedError, SecureProxyConnectionError } = require_errors();
         var buildConnector = require_connect();
-        var Client2 = require_client();
+        var Client = require_client();
         var kAgent = Symbol("proxy agent");
         var kClient = Symbol("proxy client");
         var kProxyHeaders = Symbol("proxy headers");
@@ -13268,7 +13268,7 @@ var require_proxy_agent = __commonJS({
         }, "noop");
         function defaultAgentFactory(origin, opts) {
             if (opts.connections === 1) {
-                return new Client2(origin, opts);
+                return new Client(origin, opts);
             }
             return new Pool(origin, opts);
         }
@@ -13290,7 +13290,7 @@ var require_proxy_agent = __commonJS({
                     });
                 }
                 else {
-                    this.#client = new Client2(proxyUrl, {
+                    this.#client = new Client(proxyUrl, {
                         connect
                     });
                 }
@@ -15810,13 +15810,13 @@ var require_mock_client = __commonJS({
     "../../node_modules/.pnpm/undici@6.22.0/node_modules/undici/lib/mock/mock-client.js"(exports2, module2) {
         "use strict";
         var { promisify: promisify2 } = require("node:util");
-        var Client2 = require_client();
+        var Client = require_client();
         var { buildMockDispatch } = require_mock_utils();
         var { kDispatches, kMockAgent, kClose, kOriginalClose, kOrigin, kOriginalDispatch, kConnected } = require_mock_symbols();
         var { MockInterceptor } = require_mock_interceptor();
         var Symbols = require_symbols();
         var { InvalidArgumentError } = require_errors();
-        var MockClient = class extends Client2 {
+        var MockClient = class extends Client {
             static {
                 __name(this, "MockClient");
             }
@@ -23618,7 +23618,7 @@ var require_eventsource = __commonJS({
 var require_undici = __commonJS({
     "../../node_modules/.pnpm/undici@6.22.0/node_modules/undici/index.js"(exports2, module2) {
         "use strict";
-        var Client2 = require_client();
+        var Client = require_client();
         var Dispatcher = require_dispatcher();
         var Pool = require_pool();
         var BalancedPool = require_balanced_pool();
@@ -23642,7 +23642,7 @@ var require_undici = __commonJS({
         var createRedirectInterceptor = require_redirect_interceptor();
         Object.assign(Dispatcher.prototype, api);
         module2.exports.Dispatcher = Dispatcher;
-        module2.exports.Client = Client2;
+        module2.exports.Client = Client;
         module2.exports.Pool = Pool;
         module2.exports.BalancedPool = BalancedPool;
         module2.exports.Agent = Agent2;
@@ -25191,7 +25191,7 @@ async function fetch2(...args) {
     return globalThis.fetch(...args);
 }
 __name(fetch2, "fetch");
-registerStepFunction("step//workflow@4.1.0-beta.57//fetch", fetch2);
+registerStepFunction("step//workflow@4.1.0-beta.59//fetch", fetch2);
 // workflows/addition.ts
 async function add(num, num2) {
     return num + num2;
@@ -39585,6 +39585,33 @@ var StepSchema = external_exports.object({
     // Optional in database for backwards compatibility, defaults to 1 (legacy) when reading
     specVersion: external_exports.number().optional()
 });
+// ../world/dist/waits.js
+var WaitStatusSchema = external_exports.enum([
+    "waiting",
+    "completed"
+]);
+var WaitSchema = external_exports.object({
+    waitId: external_exports.string(),
+    runId: external_exports.string(),
+    status: WaitStatusSchema,
+    resumeAt: external_exports.coerce.date().optional(),
+    completedAt: external_exports.coerce.date().optional(),
+    createdAt: external_exports.coerce.date(),
+    updatedAt: external_exports.coerce.date(),
+    specVersion: external_exports.number().optional()
+});
+// ../core/dist/encryption.js
+var KEY_LENGTH = 32;
+async function importKey(raw) {
+    if (raw.byteLength !== KEY_LENGTH) {
+        throw new Error(`Encryption key must be exactly ${KEY_LENGTH} bytes, got ${raw.byteLength}`);
+    }
+    return globalThis.crypto.subtle.importKey("raw", raw, "AES-GCM", false, [
+        "encrypt",
+        "decrypt"
+    ]);
+}
+__name(importKey, "importKey");
 // ../serde/dist/index.js
 var WORKFLOW_SERIALIZE = Symbol.for("workflow-serialize");
 var WORKFLOW_DESERIALIZE = Symbol.for("workflow-deserialize");
@@ -41675,9 +41702,7 @@ var StreamingMultipartParser = class {
         }
     }
 };
-// ../../node_modules/.pnpm/@vercel+queue@0.0.0-alpha.36/node_modules/@vercel/queue/dist/index.mjs
-var fs = __toESM(require("fs"), 1);
-var path2 = __toESM(require("path"), 1);
+// ../../node_modules/.pnpm/@vercel+queue@0.0.0-alpha.38/node_modules/@vercel/queue/dist/index.mjs
 var import_oidc = __toESM(require_dist(), 1);
 async function streamToBuffer(stream) {
     let totalLength = 0;
@@ -41750,15 +41775,6 @@ var MessageCorruptedError = class extends Error {
         this.name = "MessageCorruptedError";
     }
 };
-var QueueEmptyError = class extends Error {
-    static {
-        __name(this, "QueueEmptyError");
-    }
-    constructor(queueName, consumerGroup) {
-        super(`No messages available in queue "${queueName}" for consumer group "${consumerGroup}"`);
-        this.name = "QueueEmptyError";
-    }
-};
 var UnauthorizedError = class extends Error {
     static {
         __name(this, "UnauthorizedError");
@@ -41813,21 +41829,6 @@ var MessageAlreadyProcessedError = class extends Error {
         this.name = "MessageAlreadyProcessedError";
     }
 };
-var ConcurrencyLimitError = class extends Error {
-    static {
-        __name(this, "ConcurrencyLimitError");
-    }
-    /** Current number of in-flight messages for this consumer group. */
-    currentInflight;
-    /** Maximum allowed concurrent messages (as configured). */
-    maxConcurrency;
-    constructor(message = "Concurrency limit exceeded", currentInflight, maxConcurrency) {
-        super(message);
-        this.name = "ConcurrencyLimitError";
-        this.currentInflight = currentInflight;
-        this.maxConcurrency = maxConcurrency;
-    }
-};
 var DuplicateMessageError = class extends Error {
     static {
         __name(this, "DuplicateMessageError");
@@ -41860,185 +41861,10 @@ var ConsumerRegistryNotConfiguredError = class extends Error {
     }
 };
 var ROUTE_MAPPINGS_KEY = Symbol.for("@vercel/queue.devRouteMappings");
-function filePathToUrlPath(filePath) {
-    let urlPath = filePath.replace(/^app\//, "/").replace(/^pages\//, "/").replace(/\/route\.(ts|js|tsx|jsx)$/, "").replace(/\.(ts|js|tsx|jsx)$/, "");
-    if (!urlPath.startsWith("/")) {
-        urlPath = "/" + urlPath;
-    }
-    return urlPath;
-}
-__name(filePathToUrlPath, "filePathToUrlPath");
-function getDevRouteMappings() {
-    const g = globalThis;
-    if (ROUTE_MAPPINGS_KEY in g) {
-        return g[ROUTE_MAPPINGS_KEY] ?? null;
-    }
-    try {
-        const vercelJsonPath = path2.join(process.cwd(), "vercel.json");
-        if (!fs.existsSync(vercelJsonPath)) {
-            g[ROUTE_MAPPINGS_KEY] = null;
-            return null;
-        }
-        const vercelJson = JSON.parse(fs.readFileSync(vercelJsonPath, "utf-8"));
-        if (!vercelJson.functions) {
-            g[ROUTE_MAPPINGS_KEY] = null;
-            return null;
-        }
-        const mappings = [];
-        for (const [filePath, config3] of Object.entries(vercelJson.functions)) {
-            if (!config3.experimentalTriggers)
-                continue;
-            for (const trigger of config3.experimentalTriggers) {
-                if (trigger.type?.startsWith("queue/") && trigger.topic && trigger.consumer) {
-                    mappings.push({
-                        urlPath: filePathToUrlPath(filePath),
-                        topic: trigger.topic,
-                        consumer: trigger.consumer
-                    });
-                }
-            }
-        }
-        g[ROUTE_MAPPINGS_KEY] = mappings.length > 0 ? mappings : null;
-        return g[ROUTE_MAPPINGS_KEY];
-    }
-    catch (error45) {
-        console.warn("[Dev Mode] Failed to read vercel.json:", error45);
-        g[ROUTE_MAPPINGS_KEY] = null;
-        return null;
-    }
-}
-__name(getDevRouteMappings, "getDevRouteMappings");
-function findMatchingRoutes(topicName) {
-    const mappings = getDevRouteMappings();
-    if (!mappings) {
-        return [];
-    }
-    return mappings.filter((mapping) => {
-        if (mapping.topic.includes("*")) {
-            return matchesWildcardPattern(topicName, mapping.topic);
-        }
-        return mapping.topic === topicName;
-    });
-}
-__name(findMatchingRoutes, "findMatchingRoutes");
 function isDevMode() {
     return process.env.NODE_ENV === "development";
 }
 __name(isDevMode, "isDevMode");
-var DEV_VISIBILITY_POLL_INTERVAL = 50;
-var DEV_VISIBILITY_MAX_WAIT = 5e3;
-var DEV_VISIBILITY_BACKOFF_MULTIPLIER = 2;
-async function waitForMessageVisibility(topicName, consumerGroup, messageId) {
-    const client = new QueueClient();
-    const transport = new JsonTransport();
-    let elapsed = 0;
-    let interval = DEV_VISIBILITY_POLL_INTERVAL;
-    while (elapsed < DEV_VISIBILITY_MAX_WAIT) {
-        try {
-            await client.receiveMessageById({
-                queueName: topicName,
-                consumerGroup,
-                messageId,
-                visibilityTimeoutSeconds: 0
-            }, transport);
-            return true;
-        }
-        catch (error45) {
-            if (error45 instanceof MessageNotFoundError) {
-                await new Promise((resolve2) => setTimeout(resolve2, interval));
-                elapsed += interval;
-                interval = Math.min(interval * DEV_VISIBILITY_BACKOFF_MULTIPLIER, DEV_VISIBILITY_MAX_WAIT - elapsed);
-                continue;
-            }
-            if (error45 instanceof MessageAlreadyProcessedError) {
-                console.log(`[Dev Mode] Message already processed: topic="${topicName}" messageId="${messageId}"`);
-                return false;
-            }
-            console.error(`[Dev Mode] Error polling for message visibility: topic="${topicName}" messageId="${messageId}"`, error45);
-            return false;
-        }
-    }
-    console.warn(`[Dev Mode] Message visibility timeout after ${DEV_VISIBILITY_MAX_WAIT}ms: topic="${topicName}" messageId="${messageId}"`);
-    return false;
-}
-__name(waitForMessageVisibility, "waitForMessageVisibility");
-function triggerDevCallbacks(topicName, messageId, delaySeconds) {
-    if (delaySeconds && delaySeconds > 0) {
-        console.log(`[Dev Mode] Message sent with delay: topic="${topicName}" messageId="${messageId}" delay=${delaySeconds}s`);
-        setTimeout(() => {
-            triggerDevCallbacks(topicName, messageId);
-        }, delaySeconds * 1e3);
-        return;
-    }
-    console.log(`[Dev Mode] Message sent: topic="${topicName}" messageId="${messageId}"`);
-    const matchingRoutes = findMatchingRoutes(topicName);
-    if (matchingRoutes.length === 0) {
-        console.log(`[Dev Mode] No matching routes in vercel.json for topic "${topicName}"`);
-        return;
-    }
-    const consumerGroups = matchingRoutes.map((r) => r.consumer);
-    console.log(`[Dev Mode] Scheduling callbacks for topic="${topicName}" messageId="${messageId}" \u2192 consumers: [${consumerGroups.join(", ")}]`);
-    (async () => {
-        const firstRoute = matchingRoutes[0];
-        const isVisible = await waitForMessageVisibility(topicName, firstRoute.consumer, messageId);
-        if (!isVisible) {
-            console.warn(`[Dev Mode] Skipping callbacks - message not visible: topic="${topicName}" messageId="${messageId}"`);
-            return;
-        }
-        const port = process.env.PORT || 3e3;
-        const baseUrl = `http://localhost:${port}`;
-        for (const route of matchingRoutes) {
-            const url2 = `${baseUrl}${route.urlPath}`;
-            console.log(`[Dev Mode] Invoking handler: topic="${topicName}" consumer="${route.consumer}" messageId="${messageId}" url="${url2}"`);
-            const cloudEvent = {
-                type: "com.vercel.queue.v1beta",
-                source: `/topic/${topicName}/consumer/${route.consumer}`,
-                id: messageId,
-                datacontenttype: "application/json",
-                data: {
-                    messageId,
-                    queueName: topicName,
-                    consumerGroup: route.consumer
-                },
-                time: /* @__PURE__ */ ( /* @__PURE__ */new Date()).toISOString(),
-                specversion: "1.0"
-            };
-            try {
-                const response = await fetch(url2, {
-                    method: "POST",
-                    headers: {
-                        "Content-Type": "application/cloudevents+json"
-                    },
-                    body: JSON.stringify(cloudEvent)
-                });
-                if (response.ok) {
-                    try {
-                        const responseData = await response.json();
-                        if (responseData.status === "success") {
-                            console.log(`[Dev Mode] \u2713 Message processed successfully: topic="${topicName}" consumer="${route.consumer}" messageId="${messageId}"`);
-                        }
-                    }
-                    catch {
-                        console.warn(`[Dev Mode] Handler returned OK but response was not JSON: topic="${topicName}" consumer="${route.consumer}"`);
-                    }
-                }
-                else {
-                    try {
-                        const errorData = await response.json();
-                        console.error(`[Dev Mode] \u2717 Handler failed: topic="${topicName}" consumer="${route.consumer}" messageId="${messageId}" error="${errorData.error || response.statusText}"`);
-                    }
-                    catch {
-                        console.error(`[Dev Mode] \u2717 Handler failed: topic="${topicName}" consumer="${route.consumer}" messageId="${messageId}" status=${response.status}`);
-                    }
-                }
-            }
-            catch (error45) {
-                console.error(`[Dev Mode] \u2717 HTTP request failed: topic="${topicName}" consumer="${route.consumer}" messageId="${messageId}" url="${url2}"`, error45);
-            }
-        }
-    })();
-}
-__name(triggerDevCallbacks, "triggerDevCallbacks");
 function clearDevRouteMappings() {
     const g = globalThis;
     delete g[ROUTE_MAPPINGS_KEY];
@@ -42113,6 +41939,7 @@ var QueueClient = class {
     providedToken;
     defaultDeploymentId;
     pinToDeployment;
+    transport;
     constructor(options = {}) {
         this.baseUrl = options.baseUrl || process.env.VERCEL_QUEUE_BASE_URL || "https://vercel-queue.com";
         this.basePath = options.basePath || process.env.VERCEL_QUEUE_BASE_PATH || "/api/v3/topic";
@@ -42120,6 +41947,10 @@ var QueueClient = class {
         this.providedToken = options.token;
         this.defaultDeploymentId = options.deploymentId || process.env.VERCEL_DEPLOYMENT_ID;
         this.pinToDeployment = options.pinToDeployment ?? true;
+        this.transport = options.transport || new JsonTransport();
+    }
+    getTransport() {
+        return this.transport;
     }
     getSendDeploymentId() {
         if (isDevMode()) {
@@ -42177,6 +42008,8 @@ var QueueClient = class {
             }
             console.debug("[VQS Debug] Request:", JSON.stringify(logData, null, 2));
         }
+        init.headers.set("User-Agent", `@vercel/queue/${"0.0.0-alpha.38"}`);
+        init.headers.set("Vqs-Client-Ts", /* @__PURE__ */ ( /* @__PURE__ */new Date()).toISOString());
         const response = await fetch(url2, init);
         if (isDebugEnabled()) {
             const logData = {
@@ -42199,7 +42032,6 @@ var QueueClient = class {
     * @param options.idempotencyKey - Optional deduplication key (dedup window: min(retention, 24h))
     * @param options.retentionSeconds - Message TTL (default: 86400, min: 60, max: 86400)
     * @param options.delaySeconds - Delivery delay (default: 0, max: retentionSeconds)
-    * @param transport - Serializer for the payload
     * @returns Promise with the generated messageId
     * @throws {DuplicateMessageError} When idempotency key was already used
     * @throws {ConsumerDiscoveryError} When consumer discovery fails
@@ -42209,7 +42041,8 @@ var QueueClient = class {
     * @throws {ForbiddenError} When access is denied
     * @throws {InternalServerError} When server encounters an error
     */
-    async sendMessage(options, transport) {
+    async sendMessage(options) {
+        const transport = this.transport;
         const { queueName, payload, idempotencyKey, retentionSeconds, delaySeconds, headers: optionHeaders } = options;
         const headers = new Headers();
         if (this.customHeaders) {
@@ -42275,24 +42108,25 @@ var QueueClient = class {
     /**
     * Receive messages from a topic as an async generator.
     *
+    * When the queue is empty, the generator completes without yielding any
+    * messages. Callers should handle the case where no messages are yielded.
+    *
     * @param options - Receive options
     * @param options.queueName - Topic name (pattern: `[A-Za-z0-9_-]+`)
     * @param options.consumerGroup - Consumer group name (pattern: `[A-Za-z0-9_-]+`)
     * @param options.visibilityTimeoutSeconds - Lock duration (default: 30, min: 0, max: 3600)
     * @param options.limit - Max messages to retrieve (default: 1, min: 1, max: 10)
-    * @param options.maxConcurrency - Max in-flight messages (default: unlimited, min: 1)
-    * @param transport - Deserializer for message payloads
     * @yields Message objects with payload, messageId, receiptHandle, etc.
-    * @throws {QueueEmptyError} When no messages available
+    *         Yields nothing if queue is empty.
     * @throws {InvalidLimitError} When limit is outside 1-10 range
-    * @throws {ConcurrencyLimitError} When maxConcurrency exceeded
     * @throws {BadRequestError} When parameters are invalid
     * @throws {UnauthorizedError} When authentication fails
     * @throws {ForbiddenError} When access is denied
     * @throws {InternalServerError} When server encounters an error
     */
-    async *receiveMessages(options, transport) {
-        const { queueName, consumerGroup, visibilityTimeoutSeconds, limit, maxConcurrency } = options;
+    async *receiveMessages(options) {
+        const transport = this.transport;
+        const { queueName, consumerGroup, visibilityTimeoutSeconds, limit } = options;
         if (limit !== void 0 && (limit < 1 || limit > 10)) {
             throw new InvalidLimitError(limit);
         }
@@ -42307,9 +42141,6 @@ var QueueClient = class {
         if (limit !== void 0) {
             headers.set("Vqs-Max-Messages", limit.toString());
         }
-        if (maxConcurrency !== void 0) {
-            headers.set("Vqs-Max-Concurrency", maxConcurrency.toString());
-        }
         const effectiveDeploymentId = this.getConsumeDeploymentId();
         if (effectiveDeploymentId) {
             headers.set("Vqs-Deployment-Id", effectiveDeploymentId);
@@ -42319,19 +42150,10 @@ var QueueClient = class {
             headers
         });
         if (response.status === 204) {
-            throw new QueueEmptyError(queueName, consumerGroup);
+            return;
         }
         if (!response.ok) {
             const errorText = await response.text();
-            if (response.status === 429) {
-                let errorData = {};
-                try {
-                    errorData = JSON.parse(errorText);
-                }
-                catch {
-                }
-                throw new ConcurrencyLimitError(errorData.error || "Concurrency limit exceeded or throttled", errorData.currentInflight, errorData.maxConcurrency);
-            }
             throwCommonHttpError(response.status, response.statusText, errorText, "receive messages");
         }
         for await (const multipartMessage of parseMultipartStream(response)) {
@@ -42363,20 +42185,18 @@ var QueueClient = class {
     * @param options.consumerGroup - Consumer group name (pattern: `[A-Za-z0-9_-]+`)
     * @param options.messageId - Message ID to retrieve
     * @param options.visibilityTimeoutSeconds - Lock duration (default: 30, min: 0, max: 3600)
-    * @param options.maxConcurrency - Max in-flight messages (default: unlimited, min: 1)
-    * @param transport - Deserializer for the message payload
     * @returns Promise with the message
     * @throws {MessageNotFoundError} When message doesn't exist
     * @throws {MessageNotAvailableError} When message is in wrong state or was a duplicate
     * @throws {MessageAlreadyProcessedError} When message was already processed
-    * @throws {ConcurrencyLimitError} When maxConcurrency exceeded
     * @throws {BadRequestError} When parameters are invalid
     * @throws {UnauthorizedError} When authentication fails
     * @throws {ForbiddenError} When access is denied
     * @throws {InternalServerError} When server encounters an error
     */
-    async receiveMessageById(options, transport) {
-        const { queueName, consumerGroup, messageId, visibilityTimeoutSeconds, maxConcurrency } = options;
+    async receiveMessageById(options) {
+        const transport = this.transport;
+        const { queueName, consumerGroup, messageId, visibilityTimeoutSeconds } = options;
         const headers = new Headers({
             Authorization: `Bearer ${await this.getToken()}`,
             Accept: "multipart/mixed",
@@ -42385,9 +42205,6 @@ var QueueClient = class {
         if (visibilityTimeoutSeconds !== void 0) {
             headers.set("Vqs-Visibility-Timeout-Seconds", visibilityTimeoutSeconds.toString());
         }
-        if (maxConcurrency !== void 0) {
-            headers.set("Vqs-Max-Concurrency", maxConcurrency.toString());
-        }
         const effectiveDeploymentId = this.getConsumeDeploymentId();
         if (effectiveDeploymentId) {
             headers.set("Vqs-Deployment-Id", effectiveDeploymentId);
@@ -42416,15 +42233,6 @@ var QueueClient = class {
             if (response.status === 410) {
                 throw new MessageAlreadyProcessedError(messageId);
             }
-            if (response.status === 429) {
-                let errorData = {};
-                try {
-                    errorData = JSON.parse(errorText);
-                }
-                catch {
-                }
-                throw new ConcurrencyLimitError(errorData.error || "Concurrency limit exceeded or throttled", errorData.currentInflight, errorData.maxConcurrency);
-            }
             throwCommonHttpError(response.status, response.statusText, errorText, "receive message by ID");
         }
         for await (const multipartMessage of parseMultipartStream(response)) {
@@ -42577,449 +42385,6 @@ var QueueClient = class {
         };
     }
 };
-var ConsumerGroup = class {
-    static {
-        __name(this, "ConsumerGroup");
-    }
-    client;
-    topicName;
-    consumerGroupName;
-    visibilityTimeout;
-    refreshInterval;
-    transport;
-    /**
-    * Create a new ConsumerGroup instance.
-    *
-    * @param client - QueueClient instance to use for API calls
-    * @param topicName - Name of the topic to consume from (pattern: `[A-Za-z0-9_-]+`)
-    * @param consumerGroupName - Name of the consumer group (pattern: `[A-Za-z0-9_-]+`)
-    * @param options - Optional configuration
-    * @param options.transport - Payload serializer (default: JsonTransport)
-    * @param options.visibilityTimeoutSeconds - Message lock duration (default: 30, max: 3600)
-    * @param options.visibilityRefreshInterval - Lock refresh interval in seconds (default: visibilityTimeout / 3)
-    */
-    constructor(client, topicName, consumerGroupName, options = {}) {
-        this.client = client;
-        this.topicName = topicName;
-        this.consumerGroupName = consumerGroupName;
-        this.visibilityTimeout = options.visibilityTimeoutSeconds ?? 30;
-        this.refreshInterval = options.visibilityRefreshInterval ?? Math.floor(this.visibilityTimeout / 3);
-        this.transport = options.transport || new JsonTransport();
-    }
-    /**
-    * Starts a background loop that periodically extends the visibility timeout for a message.
-    */
-    startVisibilityExtension(receiptHandle) {
-        let isRunning = true;
-        let isResolved = false;
-        let resolveLifecycle;
-        let timeoutId = null;
-        const lifecyclePromise = new Promise((resolve2) => {
-            resolveLifecycle = resolve2;
-        });
-        const safeResolve = /* @__PURE__ */ __name(() => {
-            if (!isResolved) {
-                isResolved = true;
-                resolveLifecycle();
-            }
-        }, "safeResolve");
-        const extend2 = /* @__PURE__ */ __name(async () => {
-            if (!isRunning) {
-                safeResolve();
-                return;
-            }
-            try {
-                await this.client.changeVisibility({
-                    queueName: this.topicName,
-                    consumerGroup: this.consumerGroupName,
-                    receiptHandle,
-                    visibilityTimeoutSeconds: this.visibilityTimeout
-                });
-                if (isRunning) {
-                    timeoutId = setTimeout(() => extend2(), this.refreshInterval * 1e3);
-                }
-                else {
-                    safeResolve();
-                }
-            }
-            catch (error45) {
-                console.error(`Failed to extend visibility for receipt handle ${receiptHandle}:`, error45);
-                safeResolve();
-            }
-        }, "extend");
-        timeoutId = setTimeout(() => extend2(), this.refreshInterval * 1e3);
-        return async (waitForCompletion = false) => {
-            isRunning = false;
-            if (timeoutId) {
-                clearTimeout(timeoutId);
-                timeoutId = null;
-            }
-            if (waitForCompletion) {
-                await lifecyclePromise;
-            }
-            else {
-                safeResolve();
-            }
-        };
-    }
-    async processMessage(message, handler) {
-        const stopExtension = this.startVisibilityExtension(message.receiptHandle);
-        try {
-            await handler(message.payload, {
-                messageId: message.messageId,
-                deliveryCount: message.deliveryCount,
-                createdAt: message.createdAt,
-                topicName: this.topicName,
-                consumerGroup: this.consumerGroupName
-            });
-            await stopExtension();
-            await this.client.deleteMessage({
-                queueName: this.topicName,
-                consumerGroup: this.consumerGroupName,
-                receiptHandle: message.receiptHandle
-            });
-        }
-        catch (error45) {
-            await stopExtension();
-            if (this.transport.finalize && message.payload !== void 0 && message.payload !== null) {
-                try {
-                    await this.transport.finalize(message.payload);
-                }
-                catch (finalizeError) {
-                    console.warn("Failed to finalize message payload:", finalizeError);
-                }
-            }
-            throw error45;
-        }
-    }
-    async consume(handler, options) {
-        if (options?.messageId) {
-            const response = await this.client.receiveMessageById({
-                queueName: this.topicName,
-                consumerGroup: this.consumerGroupName,
-                messageId: options.messageId,
-                visibilityTimeoutSeconds: this.visibilityTimeout
-            }, this.transport);
-            await this.processMessage(response.message, handler);
-        }
-        else {
-            let messageFound = false;
-            for await (const message of this.client.receiveMessages({
-                queueName: this.topicName,
-                consumerGroup: this.consumerGroupName,
-                visibilityTimeoutSeconds: this.visibilityTimeout,
-                limit: 1
-            }, this.transport)) {
-                messageFound = true;
-                await this.processMessage(message, handler);
-                break;
-            }
-            if (!messageFound) {
-                throw new Error("No messages available");
-            }
-        }
-    }
-    /**
-    * Get the consumer group name
-    */
-    get name() {
-        return this.consumerGroupName;
-    }
-    /**
-    * Get the topic name this consumer group is subscribed to
-    */
-    get topic() {
-        return this.topicName;
-    }
-};
-var Topic = class {
-    static {
-        __name(this, "Topic");
-    }
-    client;
-    topicName;
-    transport;
-    /**
-    * Create a new Topic instance
-    * @param client QueueClient instance to use for API calls
-    * @param topicName Name of the topic to work with
-    * @param transport Optional serializer/deserializer for the payload (defaults to JSON)
-    */
-    constructor(client, topicName, transport) {
-        this.client = client;
-        this.topicName = topicName;
-        this.transport = transport || new JsonTransport();
-    }
-    /**
-    * Publish a message to the topic
-    * @param payload The data to publish
-    * @param options Optional publish options
-    * @returns An object containing the message ID
-    * @throws {BadRequestError} When request parameters are invalid
-    * @throws {UnauthorizedError} When authentication fails
-    * @throws {ForbiddenError} When access is denied (environment mismatch)
-    * @throws {InternalServerError} When server encounters an error
-    */
-    async publish(payload, options) {
-        const result = await this.client.sendMessage({
-            queueName: this.topicName,
-            payload,
-            idempotencyKey: options?.idempotencyKey,
-            retentionSeconds: options?.retentionSeconds,
-            delaySeconds: options?.delaySeconds,
-            headers: options?.headers
-        }, this.transport);
-        if (isDevMode()) {
-            triggerDevCallbacks(this.topicName, result.messageId);
-        }
-        return {
-            messageId: result.messageId
-        };
-    }
-    /**
-    * Create a consumer group for this topic
-    * @param consumerGroupName Name of the consumer group
-    * @param options Optional configuration for the consumer group
-    * @returns A ConsumerGroup instance
-    */
-    consumerGroup(consumerGroupName, options) {
-        const consumerOptions = {
-            ...options,
-            transport: options?.transport || this.transport
-        };
-        return new ConsumerGroup(this.client, this.topicName, consumerGroupName, consumerOptions);
-    }
-    /**
-    * Get the topic name
-    */
-    get name() {
-        return this.topicName;
-    }
-    /**
-    * Get the transport used by this topic
-    */
-    get serializer() {
-        return this.transport;
-    }
-};
-function validateWildcardPattern(pattern) {
-    const firstIndex = pattern.indexOf("*");
-    const lastIndex = pattern.lastIndexOf("*");
-    if (firstIndex !== lastIndex) {
-        return false;
-    }
-    if (firstIndex === -1) {
-        return false;
-    }
-    if (firstIndex !== pattern.length - 1) {
-        return false;
-    }
-    return true;
-}
-__name(validateWildcardPattern, "validateWildcardPattern");
-function matchesWildcardPattern(topicName, pattern) {
-    const prefix = pattern.slice(0, -1);
-    return topicName.startsWith(prefix);
-}
-__name(matchesWildcardPattern, "matchesWildcardPattern");
-function findTopicHandler(queueName, handlers) {
-    const exactHandler = handlers[queueName];
-    if (exactHandler) {
-        return exactHandler;
-    }
-    for (const pattern in handlers) {
-        if (pattern.includes("*") && matchesWildcardPattern(queueName, pattern)) {
-            return handlers[pattern];
-        }
-    }
-    return null;
-}
-__name(findTopicHandler, "findTopicHandler");
-async function parseCallback(request) {
-    const contentType = request.headers.get("content-type");
-    if (!contentType || !contentType.includes("application/cloudevents+json")) {
-        throw new Error("Invalid content type: expected 'application/cloudevents+json'");
-    }
-    let cloudEvent;
-    try {
-        cloudEvent = await request.json();
-    }
-    catch (error45) {
-        throw new Error("Failed to parse CloudEvent from request body");
-    }
-    if (!cloudEvent.type || !cloudEvent.source || !cloudEvent.id || typeof cloudEvent.data !== "object" || cloudEvent.data == null) {
-        throw new Error("Invalid CloudEvent: missing required fields");
-    }
-    if (cloudEvent.type !== "com.vercel.queue.v1beta") {
-        throw new Error(`Invalid CloudEvent type: expected 'com.vercel.queue.v1beta', got '${cloudEvent.type}'`);
-    }
-    const missingFields = [];
-    if (!("queueName" in cloudEvent.data))
-        missingFields.push("queueName");
-    if (!("consumerGroup" in cloudEvent.data))
-        missingFields.push("consumerGroup");
-    if (!("messageId" in cloudEvent.data))
-        missingFields.push("messageId");
-    if (missingFields.length > 0) {
-        throw new Error(`Missing required CloudEvent data fields: ${missingFields.join(", ")}`);
-    }
-    const { messageId, queueName, consumerGroup } = cloudEvent.data;
-    return {
-        queueName,
-        consumerGroup,
-        messageId
-    };
-}
-__name(parseCallback, "parseCallback");
-function createCallbackHandler(handlers, client, visibilityTimeoutSeconds) {
-    for (const topicPattern in handlers) {
-        if (topicPattern.includes("*")) {
-            if (!validateWildcardPattern(topicPattern)) {
-                throw new Error(`Invalid wildcard pattern "${topicPattern}": * may only appear once and must be at the end of the topic name`);
-            }
-        }
-    }
-    const routeHandler = /* @__PURE__ */ __name(async (request) => {
-        try {
-            const { queueName, consumerGroup, messageId } = await parseCallback(request);
-            const topicHandler = findTopicHandler(queueName, handlers);
-            if (!topicHandler) {
-                const availableTopics = Object.keys(handlers).join(", ");
-                return Response.json({
-                    error: `No handler found for topic: ${queueName}`,
-                    availableTopics
-                }, {
-                    status: 404
-                });
-            }
-            const consumerGroupHandler = topicHandler[consumerGroup];
-            if (!consumerGroupHandler) {
-                const availableGroups = Object.keys(topicHandler).join(", ");
-                return Response.json({
-                    error: `No handler found for consumer group "${consumerGroup}" in topic "${queueName}".`,
-                    availableGroups
-                }, {
-                    status: 404
-                });
-            }
-            const topic = new Topic(client, queueName);
-            const cg = topic.consumerGroup(consumerGroup, visibilityTimeoutSeconds !== void 0 ? {
-                visibilityTimeoutSeconds
-            } : void 0);
-            await cg.consume(consumerGroupHandler, {
-                messageId
-            });
-            return Response.json({
-                status: "success"
-            });
-        }
-        catch (error45) {
-            console.error("Queue callback error:", error45);
-            if (error45 instanceof Error && (error45.message.includes("Missing required CloudEvent data fields") || error45.message.includes("Invalid CloudEvent") || error45.message.includes("Invalid CloudEvent type") || error45.message.includes("Invalid content type") || error45.message.includes("Failed to parse CloudEvent"))) {
-                return Response.json({
-                    error: error45.message
-                }, {
-                    status: 400
-                });
-            }
-            return Response.json({
-                error: "Failed to process queue message"
-            }, {
-                status: 500
-            });
-        }
-    }, "routeHandler");
-    return routeHandler;
-}
-__name(createCallbackHandler, "createCallbackHandler");
-function handleCallback(handlers, options) {
-    return createCallbackHandler(handlers, options?.client || new QueueClient(), options?.visibilityTimeoutSeconds);
-}
-__name(handleCallback, "handleCallback");
-async function send(topicName, payload, options) {
-    const transport = options?.transport || new JsonTransport();
-    const client = options?.client || new QueueClient();
-    const result = await client.sendMessage({
-        queueName: topicName,
-        payload,
-        idempotencyKey: options?.idempotencyKey,
-        retentionSeconds: options?.retentionSeconds,
-        delaySeconds: options?.delaySeconds,
-        headers: options?.headers
-    }, transport);
-    if (isDevMode()) {
-        triggerDevCallbacks(topicName, result.messageId, options?.delaySeconds);
-    }
-    return {
-        messageId: result.messageId
-    };
-}
-__name(send, "send");
-var Client = class {
-    static {
-        __name(this, "Client");
-    }
-    client;
-    /**
-    * Create a new Client
-    * @param options QueueClient configuration options
-    */
-    constructor(options = {}) {
-        this.client = new QueueClient(options);
-    }
-    /**
-    * Send a message to a topic
-    * @param topicName Name of the topic to send to
-    * @param payload The data to send
-    * @param options Optional publish options and transport
-    * @returns Promise with the message ID
-    * @throws {BadRequestError} When request parameters are invalid
-    * @throws {UnauthorizedError} When authentication fails
-    * @throws {ForbiddenError} When access is denied (environment mismatch)
-    * @throws {InternalServerError} When server encounters an error
-    */
-    async send(topicName, payload, options) {
-        return send(topicName, payload, {
-            ...options,
-            client: this.client
-        });
-    }
-    /**
-    * Create a callback handler for processing queue messages.
-    * Returns a Next.js route handler function that routes messages to appropriate handlers.
-    *
-    * @param handlers - Object with topic-specific handlers organized by consumer groups
-    * @param options - Optional configuration
-    * @param options.visibilityTimeoutSeconds - Message lock duration (default: 30, max: 3600)
-    * @returns A Next.js route handler function
-    *
-    * @example
-    * ```typescript
-    * // Basic usage
-    * export const POST = client.handleCallback({
-    *   "user-events": {
-    *     "welcome": (user, metadata) => console.log("Welcoming user", user),
-    *     "analytics": (user, metadata) => console.log("Tracking user", user),
-    *   },
-    * });
-    *
-    * // With custom visibility timeout
-    * export const POST = client.handleCallback({
-    *   "video-processing": {
-    *     "transcode": async (video) => await transcodeVideo(video),
-    *   },
-    * }, {
-    *   visibilityTimeoutSeconds: 300,  // 5 minutes for long operations
-    * });
-    * ```
-    */
-    handleCallback(handlers, options) {
-        return handleCallback(handlers, {
-            ...options,
-            client: this.client
-        });
-    }
-};
 // ../world-local/dist/queue.js
 var import_async_sema = __toESM(require_lib(), 1);
 var import_undici = __toESM(require_undici(), 1);
@@ -43027,12 +42392,12 @@ var LOCAL_QUEUE_MAX_VISIBILITY = parseInt(process.env.WORKFLOW_LOCAL_QUEUE_MAX_V
 var MAX_SAFE_TIMEOUT_MS = 2147483647;
 var DEFAULT_CONCURRENCY_LIMIT = 1e3;
 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,
-    connections: 1e3,
-    keepAliveTimeout: 3e4
-});
 function createQueue(config3) {
+    const httpAgent = new import_undici.Agent({
+        headersTimeout: 0,
+        connections: 1e3,
+        keepAliveTimeout: 3e4
+    });
     const transport = new JsonTransport();
     const generateId2 = monotonicFactory();
     const semaphore = new import_async_sema.Sema(WORKFLOW_LOCAL_QUEUE_CONCURRENCY);
@@ -43193,7 +42558,10 @@ function createQueue(config3) {
     return {
         queue,
         createQueueHandler,
-        getDeploymentId
+        getDeploymentId,
+        async close() {
+            await httpAgent.close();
+        }
     };
 }
 __name(createQueue, "createQueue");
@@ -43764,6 +43132,17 @@ async function handleLegacyEvent(basedir, runId, data, currentRun, params) {
 }
 __name(handleLegacyEvent, "handleLegacyEvent");
 // ../world-local/dist/storage/events-storage.js
+async function deleteAllWaitsForRun(basedir, runId) {
+    const waitsDir = import_node_path5.default.join(basedir, "waits");
+    const files = await listJSONFiles(waitsDir);
+    for (const file2 of files) {
+        if (file2.startsWith(`${runId}-`)) {
+            const waitPath = import_node_path5.default.join(waitsDir, `${file2}.json`);
+            await deleteJSON(waitPath);
+        }
+    }
+}
+__name(deleteAllWaitsForRun, "deleteAllWaitsForRun");
 function createEventsStorage(basedir) {
     return {
         async create(runId, data, params) {
@@ -43834,7 +43213,7 @@ function createEventsStorage(basedir) {
                         status: 409
                     });
                 }
-                if (data.eventType === "step_created" || data.eventType === "hook_created") {
+                if (data.eventType === "step_created" || data.eventType === "hook_created" || data.eventType === "wait_created") {
                     throw new WorkflowAPIError(`Cannot create new entities on run in terminal state "${currentRun.status}"`, {
                         status: 409
                     });
@@ -43892,6 +43271,7 @@ function createEventsStorage(basedir) {
             let run;
             let step;
             let hook;
+            let wait;
             if (data.eventType === "run_created" && "eventData" in data) {
                 const runData = data.eventData;
                 run = {
@@ -43960,7 +43340,10 @@ function createEventsStorage(basedir) {
                     await writeJSON(runPath, run, {
                         overwrite: true
                     });
-                    await deleteAllHooksForRun(basedir, effectiveRunId);
+                    await Promise.all([
+                        deleteAllHooksForRun(basedir, effectiveRunId),
+                        deleteAllWaitsForRun(basedir, effectiveRunId)
+                    ]);
                 }
             }
             else if (data.eventType === "run_failed" && "eventData" in data) {
@@ -43990,7 +43373,10 @@ function createEventsStorage(basedir) {
                     await writeJSON(runPath, run, {
                         overwrite: true
                     });
-                    await deleteAllHooksForRun(basedir, effectiveRunId);
+                    await Promise.all([
+                        deleteAllHooksForRun(basedir, effectiveRunId),
+                        deleteAllWaitsForRun(basedir, effectiveRunId)
+                    ]);
                 }
             }
             else if (data.eventType === "run_cancelled") {
@@ -44015,7 +43401,10 @@ function createEventsStorage(basedir) {
                     await writeJSON(runPath, run, {
                         overwrite: true
                     });
-                    await deleteAllHooksForRun(basedir, effectiveRunId);
+                    await Promise.all([
+                        deleteAllHooksForRun(basedir, effectiveRunId),
+                        deleteAllWaitsForRun(basedir, effectiveRunId)
+                    ]);
                 }
             }
             else if (
@@ -44188,6 +43577,52 @@ function createEventsStorage(basedir) {
                 const hookPath = import_node_path5.default.join(basedir, "hooks", `${data.correlationId}.json`);
                 await deleteJSON(hookPath);
             }
+            else if (data.eventType === "wait_created" && "eventData" in data) {
+                const waitData = data.eventData;
+                const waitCompositeKey = `${effectiveRunId}-${data.correlationId}`;
+                const waitPath = import_node_path5.default.join(basedir, "waits", `${waitCompositeKey}.json`);
+                const existingWait = await readJSON(waitPath, WaitSchema);
+                if (existingWait) {
+                    throw new WorkflowAPIError(`Wait "${data.correlationId}" already exists`, {
+                        status: 409
+                    });
+                }
+                wait = {
+                    waitId: waitCompositeKey,
+                    runId: effectiveRunId,
+                    status: "waiting",
+                    resumeAt: waitData.resumeAt,
+                    completedAt: void 0,
+                    createdAt: now,
+                    updatedAt: now,
+                    specVersion: effectiveSpecVersion
+                };
+                await writeJSON(waitPath, wait);
+            }
+            else if (data.eventType === "wait_completed") {
+                const waitCompositeKey = `${effectiveRunId}-${data.correlationId}`;
+                const waitPath = import_node_path5.default.join(basedir, "waits", `${waitCompositeKey}.json`);
+                const existingWait = await readJSON(waitPath, WaitSchema);
+                if (!existingWait) {
+                    throw new WorkflowAPIError(`Wait "${data.correlationId}" not found`, {
+                        status: 404
+                    });
+                }
+                if (existingWait.status === "completed") {
+                    throw new WorkflowAPIError(`Wait "${data.correlationId}" already completed`, {
+                        status: 409
+                    });
+                }
+                wait = {
+                    ...existingWait,
+                    status: "completed",
+                    completedAt: now,
+                    updatedAt: now
+                };
+                await writeJSON(waitPath, wait, {
+                    overwrite: true
+                });
+            }
             const compositeKey = `${effectiveRunId}-${eventId}`;
             const eventPath = import_node_path5.default.join(basedir, "events", `${compositeKey}.json`);
             await writeJSON(eventPath, event);
@@ -44197,7 +43632,8 @@ function createEventsStorage(basedir) {
                 event: filteredEvent,
                 run,
                 step,
-                hook
+                hook,
+                wait
             };
         },
         async list(params) {
@@ -44338,286 +43774,1715 @@ function createStepsStorage(basedir) {
                 getCreatedAt: getObjectCreatedAt("step"),
                 getId: /* @__PURE__ */ __name((step) => step.stepId, "getId")
             });
-            if (resolveData === "none") {
-                return {
-                    ...result,
-                    data: result.data.map((step) => ({
-                        ...step,
-                        input: void 0,
-                        output: void 0
-                    }))
-                };
+            if (resolveData === "none") {
+                return {
+                    ...result,
+                    data: result.data.map((step) => ({
+                        ...step,
+                        input: void 0,
+                        output: void 0
+                    }))
+                };
+            }
+            return result;
+        }, "list")
+    };
+}
+__name(createStepsStorage, "createStepsStorage");
+// ../world-local/dist/storage/index.js
+function createStorage(basedir) {
+    const storage = {
+        runs: createRunsStorage(basedir),
+        steps: createStepsStorage(basedir),
+        events: createEventsStorage(basedir),
+        hooks: createHooksStorage(basedir)
+    };
+    return {
+        runs: instrumentObject("world.runs", storage.runs),
+        steps: instrumentObject("world.steps", storage.steps),
+        events: instrumentObject("world.events", storage.events),
+        hooks: instrumentObject("world.hooks", storage.hooks)
+    };
+}
+__name(createStorage, "createStorage");
+// ../world-local/dist/streamer.js
+var import_node_events = require("node:events");
+var import_node_path8 = __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
+    ]);
+    return Buffer.concat([
+        eofByte,
+        chunk.chunk
+    ]);
+}
+__name(serializeChunk, "serializeChunk");
+function deserializeChunk(serialized) {
+    const eof = serialized[0] === 1;
+    const chunk = Buffer.from(serialized.subarray(1));
+    return {
+        eof,
+        chunk
+    };
+}
+__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_path8.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");
+    function toBuffer(chunk) {
+        if (typeof chunk === "string") {
+            return Buffer.from(new TextEncoder().encode(chunk));
+        }
+        else if (chunk instanceof Buffer) {
+            return chunk;
+        }
+        else {
+            return Buffer.from(chunk);
+        }
+    }
+    __name(toBuffer, "toBuffer");
+    return {
+        async writeToStream(name, _runId, chunk) {
+            const chunkId = `chnk_${monotonicUlid2()}`;
+            const runId = await _runId;
+            await registerStreamForRun(runId, name);
+            const chunkBuffer = toBuffer(chunk);
+            const serialized = serializeChunk({
+                chunk: chunkBuffer,
+                eof: false
+            });
+            const chunkPath = import_node_path8.default.join(basedir, "streams", "chunks", `${name}-${chunkId}.bin`);
+            await write(chunkPath, serialized);
+            const chunkData = Uint8Array.from(chunkBuffer);
+            streamEmitter.emit(`chunk:${name}`, {
+                streamName: name,
+                chunkData,
+                chunkId
+            });
+        },
+        async writeToStreamMulti(name, _runId, chunks) {
+            if (chunks.length === 0)
+                return;
+            const chunkIds = chunks.map(() => `chnk_${monotonicUlid2()}`);
+            const runId = await _runId;
+            await registerStreamForRun(runId, name);
+            const chunkBuffers = chunks.map((chunk) => toBuffer(chunk));
+            const writePromises = chunkBuffers.map(async (chunkBuffer, i) => {
+                const chunkId = chunkIds[i];
+                const serialized = serializeChunk({
+                    chunk: chunkBuffer,
+                    eof: false
+                });
+                const chunkPath = import_node_path8.default.join(basedir, "streams", "chunks", `${name}-${chunkId}.bin`);
+                await write(chunkPath, serialized);
+                return {
+                    chunkId,
+                    chunkData: Uint8Array.from(chunkBuffer)
+                };
+            });
+            for (const writePromise of writePromises) {
+                const { chunkId, chunkData } = await writePromise;
+                streamEmitter.emit(`chunk:${name}`, {
+                    streamName: name,
+                    chunkData,
+                    chunkId
+                });
+            }
+        },
+        async closeStream(name, _runId) {
+            const chunkId = `chnk_${monotonicUlid2()}`;
+            const runId = await _runId;
+            await registerStreamForRun(runId, name);
+            const chunkPath = import_node_path8.default.join(basedir, "streams", "chunks", `${name}-${chunkId}.bin`);
+            await write(chunkPath, serializeChunk({
+                chunk: Buffer.from([]),
+                eof: true
+            }));
+            streamEmitter.emit(`close:${name}`, {
+                streamName: name
+            });
+        },
+        async listStreamsByRunId(runId) {
+            const runStreamsPath = import_node_path8.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_path8.default.join(basedir, "streams", "chunks");
+            let removeListeners = /* @__PURE__ */ __name(() => {
+            }, "removeListeners");
+            return new ReadableStream({
+                async start(controller) {
+                    const deliveredChunkIds = /* @__PURE__ */ new Set();
+                    const bufferedEventChunks = [];
+                    let isReadingFromDisk = true;
+                    let pendingClose = false;
+                    const chunkListener = /* @__PURE__ */ __name((event) => {
+                        deliveredChunkIds.add(event.chunkId);
+                        if (event.chunkData.byteLength === 0) {
+                            return;
+                        }
+                        if (isReadingFromDisk) {
+                            bufferedEventChunks.push({
+                                chunkId: event.chunkId,
+                                chunkData: Uint8Array.from(event.chunkData)
+                            });
+                        }
+                        else {
+                            controller.enqueue(Uint8Array.from(event.chunkData));
+                        }
+                    }, "chunkListener");
+                    const closeListener = /* @__PURE__ */ __name(() => {
+                        if (isReadingFromDisk) {
+                            pendingClose = true;
+                            return;
+                        }
+                        streamEmitter.off(`chunk:${name}`, chunkListener);
+                        streamEmitter.off(`close:${name}`, closeListener);
+                        try {
+                            controller.close();
+                        }
+                        catch {
+                        }
+                    }, "closeListener");
+                    removeListeners = closeListener;
+                    streamEmitter.on(`chunk:${name}`, chunkListener);
+                    streamEmitter.on(`close:${name}`, closeListener);
+                    const [binFiles, jsonFiles] = await Promise.all([
+                        listFilesByExtension(chunksDir, ".bin"),
+                        listFilesByExtension(chunksDir, ".json")
+                    ]);
+                    const fileExtMap = /* @__PURE__ */ new Map();
+                    for (const f of jsonFiles)
+                        fileExtMap.set(f, ".json");
+                    for (const f of binFiles)
+                        fileExtMap.set(f, ".bin");
+                    const chunkFiles = [
+                        ...fileExtMap.keys()
+                    ].filter((file2) => file2.startsWith(`${name}-`)).sort();
+                    let isComplete = false;
+                    for (let i = startIndex; i < chunkFiles.length; i++) {
+                        const file2 = chunkFiles[i];
+                        const chunkId = file2.substring(name.length + 1);
+                        if (deliveredChunkIds.has(chunkId)) {
+                            continue;
+                        }
+                        const ext = fileExtMap.get(file2) ?? ".bin";
+                        const chunk = deserializeChunk(await readBuffer(import_node_path8.default.join(chunksDir, `${file2}${ext}`)));
+                        if (chunk?.eof === true) {
+                            isComplete = true;
+                            break;
+                        }
+                        if (chunk.chunk.byteLength) {
+                            controller.enqueue(Uint8Array.from(chunk.chunk));
+                        }
+                    }
+                    isReadingFromDisk = false;
+                    bufferedEventChunks.sort((a, b) => a.chunkId.localeCompare(b.chunkId));
+                    for (const buffered of bufferedEventChunks) {
+                        controller.enqueue(Uint8Array.from(buffered.chunkData));
+                    }
+                    if (isComplete) {
+                        removeListeners();
+                        try {
+                            controller.close();
+                        }
+                        catch {
+                        }
+                        return;
+                    }
+                    if (pendingClose) {
+                        streamEmitter.off(`chunk:${name}`, chunkListener);
+                        streamEmitter.off(`close:${name}`, closeListener);
+                        try {
+                            controller.close();
+                        }
+                        catch {
+                        }
+                    }
+                },
+                cancel() {
+                    removeListeners();
+                }
+            });
+        }
+    };
+}
+__name(createStreamer, "createStreamer");
+// ../world-local/dist/index.js
+function createLocalWorld(args) {
+    const definedArgs = args ? Object.fromEntries(Object.entries(args).filter(([, value]) => value !== void 0)) : {};
+    const mergedConfig = {
+        ...config2.value,
+        ...definedArgs
+    };
+    const queue = createQueue(mergedConfig);
+    return {
+        ...queue,
+        ...createStorage(mergedConfig.dataDir),
+        ...createStreamer(mergedConfig.dataDir),
+        async start() {
+            await initDataDir(mergedConfig.dataDir);
+        },
+        async close() {
+            await queue.close();
+        }
+    };
+}
+__name(createLocalWorld, "createLocalWorld");
+// ../world-vercel/dist/encryption.js
+var import_node_crypto2 = require("node:crypto");
+var import_oidc2 = __toESM(require_dist(), 1);
+var KEY_BYTES = 32;
+async function deriveRunKey(deploymentKey, projectId, runId) {
+    if (deploymentKey.length !== KEY_BYTES) {
+        throw new Error(`Invalid deployment key length: expected ${KEY_BYTES} bytes for AES-256, got ${deploymentKey.length} bytes`);
+    }
+    if (!projectId || typeof projectId !== "string") {
+        throw new Error("projectId must be a non-empty string");
+    }
+    const baseKey = await import_node_crypto2.webcrypto.subtle.importKey("raw", deploymentKey, "HKDF", false, [
+        "deriveBits"
+    ]);
+    const info = new TextEncoder().encode(`${projectId}|${runId}`);
+    const derivedBits = await import_node_crypto2.webcrypto.subtle.deriveBits({
+        name: "HKDF",
+        hash: "SHA-256",
+        salt: new Uint8Array(32),
+        info
+    }, baseKey, KEY_BYTES * 8
+    // bits
+    );
+    return new Uint8Array(derivedBits);
+}
+__name(deriveRunKey, "deriveRunKey");
+async function fetchRunKey(deploymentId, projectId, runId, options) {
+    const oidcToken = await (0, import_oidc2.getVercelOidcToken)().catch(() => null);
+    const token = options?.token ?? oidcToken ?? process.env.VERCEL_TOKEN;
+    if (!token) {
+        throw new Error("Cannot fetch run key: no OIDC token or VERCEL_TOKEN available");
+    }
+    const params = new URLSearchParams({
+        projectId,
+        runId
+    });
+    const response = await fetch(`https://api.vercel.com/v1/workflow/run-key/${deploymentId}?${params}`, {
+        headers: {
+            Authorization: `Bearer ${token}`
+        }
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch run key for ${runId} (deployment ${deploymentId}): HTTP ${response.status}`);
+    }
+    const data = await response.json();
+    const result = object({
+        key: string2()
+    }).safeParse(data);
+    if (!result.success) {
+        throw new Error('Invalid response from Vercel API, missing "key" field');
+    }
+    return Buffer.from(result.data.key, "base64");
+}
+__name(fetchRunKey, "fetchRunKey");
+function createGetEncryptionKeyForRun(projectId, token) {
+    if (!projectId)
+        return void 0;
+    const currentDeploymentId = process.env.VERCEL_DEPLOYMENT_ID;
+    let localDeploymentKey;
+    function getLocalDeploymentKey() {
+        if (localDeploymentKey)
+            return localDeploymentKey;
+        const deploymentKeyBase64 = process.env.VERCEL_DEPLOYMENT_KEY;
+        if (!deploymentKeyBase64)
+            return void 0;
+        localDeploymentKey = Buffer.from(deploymentKeyBase64, "base64");
+        return localDeploymentKey;
+    }
+    __name(getLocalDeploymentKey, "getLocalDeploymentKey");
+    return /* @__PURE__ */ __name(async function getEncryptionKeyForRun(run, context) {
+        const runId = typeof run === "string" ? run : run.runId;
+        const deploymentId = typeof run === "string" ? context?.deploymentId : run.deploymentId;
+        if (!deploymentId || deploymentId === currentDeploymentId) {
+            const localKey = getLocalDeploymentKey();
+            if (!localKey)
+                return void 0;
+            return deriveRunKey(localKey, projectId, runId);
+        }
+        return fetchRunKey(deploymentId, projectId, runId, {
+            token
+        });
+    }, "getEncryptionKeyForRun");
+}
+__name(createGetEncryptionKeyForRun, "createGetEncryptionKeyForRun");
+// ../../node_modules/.pnpm/@vercel+queue@0.0.0-alpha.38/node_modules/@vercel/queue/dist/web.mjs
+var fs2 = __toESM(require("fs"), 1);
+var path9 = __toESM(require("path"), 1);
+var import_oidc3 = __toESM(require_dist(), 1);
+var MessageNotFoundError2 = class extends Error {
+    static {
+        __name(this, "MessageNotFoundError");
+    }
+    constructor(messageId) {
+        super(`Message ${messageId} not found`);
+        this.name = "MessageNotFoundError";
+    }
+};
+var MessageNotAvailableError2 = class extends Error {
+    static {
+        __name(this, "MessageNotAvailableError");
+    }
+    constructor(messageId, reason) {
+        super(`Message ${messageId} not available for processing${reason ? `: ${reason}` : ""}`);
+        this.name = "MessageNotAvailableError";
+    }
+};
+var MessageCorruptedError2 = class extends Error {
+    static {
+        __name(this, "MessageCorruptedError");
+    }
+    constructor(messageId, reason) {
+        super(`Message ${messageId} is corrupted: ${reason}`);
+        this.name = "MessageCorruptedError";
+    }
+};
+var UnauthorizedError2 = class extends Error {
+    static {
+        __name(this, "UnauthorizedError");
+    }
+    constructor(message = "Missing or invalid authentication token") {
+        super(message);
+        this.name = "UnauthorizedError";
+    }
+};
+var ForbiddenError2 = class extends Error {
+    static {
+        __name(this, "ForbiddenError");
+    }
+    constructor(message = "Queue environment doesn't match token environment") {
+        super(message);
+        this.name = "ForbiddenError";
+    }
+};
+var BadRequestError2 = class extends Error {
+    static {
+        __name(this, "BadRequestError");
+    }
+    constructor(message) {
+        super(message);
+        this.name = "BadRequestError";
+    }
+};
+var InternalServerError2 = class extends Error {
+    static {
+        __name(this, "InternalServerError");
+    }
+    constructor(message = "Unexpected server error") {
+        super(message);
+        this.name = "InternalServerError";
+    }
+};
+var InvalidLimitError2 = class extends Error {
+    static {
+        __name(this, "InvalidLimitError");
+    }
+    constructor(limit, min = 1, max = 10) {
+        super(`Invalid limit: ${limit}. Limit must be between ${min} and ${max}.`);
+        this.name = "InvalidLimitError";
+    }
+};
+var MessageAlreadyProcessedError2 = class extends Error {
+    static {
+        __name(this, "MessageAlreadyProcessedError");
+    }
+    constructor(messageId) {
+        super(`Message ${messageId} has already been processed`);
+        this.name = "MessageAlreadyProcessedError";
+    }
+};
+var DuplicateMessageError2 = class extends Error {
+    static {
+        __name(this, "DuplicateMessageError");
+    }
+    idempotencyKey;
+    constructor(message, idempotencyKey) {
+        super(message);
+        this.name = "DuplicateMessageError";
+        this.idempotencyKey = idempotencyKey;
+    }
+};
+var ConsumerDiscoveryError2 = class extends Error {
+    static {
+        __name(this, "ConsumerDiscoveryError");
+    }
+    deploymentId;
+    constructor(message, deploymentId) {
+        super(message);
+        this.name = "ConsumerDiscoveryError";
+        this.deploymentId = deploymentId;
+    }
+};
+var ConsumerRegistryNotConfiguredError2 = class extends Error {
+    static {
+        __name(this, "ConsumerRegistryNotConfiguredError");
+    }
+    constructor(message = "Consumer registry not configured") {
+        super(message);
+        this.name = "ConsumerRegistryNotConfiguredError";
+    }
+};
+var ROUTE_MAPPINGS_KEY2 = Symbol.for("@vercel/queue.devRouteMappings");
+function filePathToUrlPath(filePath) {
+    let urlPath = filePath.replace(/^app\//, "/").replace(/^pages\//, "/").replace(/\/route\.(ts|mts|js|mjs|tsx|jsx)$/, "").replace(/\.(ts|mts|js|mjs|tsx|jsx)$/, "");
+    if (!urlPath.startsWith("/")) {
+        urlPath = "/" + urlPath;
+    }
+    return urlPath;
+}
+__name(filePathToUrlPath, "filePathToUrlPath");
+function filePathToConsumerGroup(filePath) {
+    return filePath.replace(/_/g, "__").replace(/\//g, "_S").replace(/\./g, "_D");
+}
+__name(filePathToConsumerGroup, "filePathToConsumerGroup");
+function getDevRouteMappings() {
+    const g = globalThis;
+    if (ROUTE_MAPPINGS_KEY2 in g) {
+        return g[ROUTE_MAPPINGS_KEY2] ?? null;
+    }
+    try {
+        const vercelJsonPath = path9.join(process.cwd(), "vercel.json");
+        if (!fs2.existsSync(vercelJsonPath)) {
+            g[ROUTE_MAPPINGS_KEY2] = null;
+            return null;
+        }
+        const vercelJson = JSON.parse(fs2.readFileSync(vercelJsonPath, "utf-8"));
+        if (!vercelJson.functions) {
+            g[ROUTE_MAPPINGS_KEY2] = null;
+            return null;
+        }
+        const mappings = [];
+        for (const [filePath, config3] of Object.entries(vercelJson.functions)) {
+            if (!config3.experimentalTriggers)
+                continue;
+            for (const trigger of config3.experimentalTriggers) {
+                if (trigger.type?.startsWith("queue/") && trigger.topic) {
+                    mappings.push({
+                        urlPath: filePathToUrlPath(filePath),
+                        topic: trigger.topic,
+                        consumer: filePathToConsumerGroup(filePath)
+                    });
+                }
+            }
+        }
+        g[ROUTE_MAPPINGS_KEY2] = mappings.length > 0 ? mappings : null;
+        return g[ROUTE_MAPPINGS_KEY2];
+    }
+    catch (error45) {
+        console.warn("[Dev Mode] Failed to read vercel.json:", error45);
+        g[ROUTE_MAPPINGS_KEY2] = null;
+        return null;
+    }
+}
+__name(getDevRouteMappings, "getDevRouteMappings");
+function findMatchingRoutes(topicName) {
+    const mappings = getDevRouteMappings();
+    if (!mappings) {
+        return [];
+    }
+    return mappings.filter((mapping) => {
+        if (mapping.topic.includes("*")) {
+            return matchesWildcardPattern(topicName, mapping.topic);
+        }
+        return mapping.topic === topicName;
+    });
+}
+__name(findMatchingRoutes, "findMatchingRoutes");
+function isDevMode2() {
+    return process.env.NODE_ENV === "development";
+}
+__name(isDevMode2, "isDevMode");
+var DEV_VISIBILITY_POLL_INTERVAL = 50;
+var DEV_VISIBILITY_MAX_WAIT = 5e3;
+var DEV_VISIBILITY_BACKOFF_MULTIPLIER = 2;
+async function waitForMessageVisibility(topicName, consumerGroup, messageId) {
+    const client = new QueueClient2();
+    let elapsed = 0;
+    let interval = DEV_VISIBILITY_POLL_INTERVAL;
+    while (elapsed < DEV_VISIBILITY_MAX_WAIT) {
+        try {
+            await client.receiveMessageById({
+                queueName: topicName,
+                consumerGroup,
+                messageId,
+                visibilityTimeoutSeconds: 0
+            });
+            return true;
+        }
+        catch (error45) {
+            if (error45 instanceof MessageNotFoundError2) {
+                await new Promise((resolve2) => setTimeout(resolve2, interval));
+                elapsed += interval;
+                interval = Math.min(interval * DEV_VISIBILITY_BACKOFF_MULTIPLIER, DEV_VISIBILITY_MAX_WAIT - elapsed);
+                continue;
+            }
+            if (error45 instanceof MessageAlreadyProcessedError2) {
+                console.log(`[Dev Mode] Message already processed: topic="${topicName}" messageId="${messageId}"`);
+                return false;
+            }
+            console.error(`[Dev Mode] Error polling for message visibility: topic="${topicName}" messageId="${messageId}"`, error45);
+            return false;
+        }
+    }
+    console.warn(`[Dev Mode] Message visibility timeout after ${DEV_VISIBILITY_MAX_WAIT}ms: topic="${topicName}" messageId="${messageId}"`);
+    return false;
+}
+__name(waitForMessageVisibility, "waitForMessageVisibility");
+function triggerDevCallbacks(topicName, messageId, delaySeconds) {
+    if (delaySeconds && delaySeconds > 0) {
+        console.log(`[Dev Mode] Message sent with delay: topic="${topicName}" messageId="${messageId}" delay=${delaySeconds}s`);
+        setTimeout(() => {
+            triggerDevCallbacks(topicName, messageId);
+        }, delaySeconds * 1e3);
+        return;
+    }
+    console.log(`[Dev Mode] Message sent: topic="${topicName}" messageId="${messageId}"`);
+    const matchingRoutes = findMatchingRoutes(topicName);
+    if (matchingRoutes.length === 0) {
+        console.log(`[Dev Mode] No matching routes in vercel.json for topic "${topicName}"`);
+        return;
+    }
+    const consumerGroups = matchingRoutes.map((r) => r.consumer);
+    console.log(`[Dev Mode] Scheduling callbacks for topic="${topicName}" messageId="${messageId}" \u2192 consumers: [${consumerGroups.join(", ")}]`);
+    (async () => {
+        const firstRoute = matchingRoutes[0];
+        const isVisible = await waitForMessageVisibility(topicName, firstRoute.consumer, messageId);
+        if (!isVisible) {
+            console.warn(`[Dev Mode] Skipping callbacks - message not visible: topic="${topicName}" messageId="${messageId}"`);
+            return;
+        }
+        const port = process.env.PORT || 3e3;
+        const baseUrl = `http://localhost:${port}`;
+        for (const route of matchingRoutes) {
+            const url2 = `${baseUrl}${route.urlPath}`;
+            console.log(`[Dev Mode] Invoking handler: topic="${topicName}" consumer="${route.consumer}" messageId="${messageId}" url="${url2}"`);
+            try {
+                const response = await fetch(url2, {
+                    method: "POST",
+                    headers: {
+                        "ce-type": CLOUD_EVENT_TYPE_V2BETA,
+                        "ce-vqsqueuename": topicName,
+                        "ce-vqsconsumergroup": route.consumer,
+                        "ce-vqsmessageid": messageId
+                    }
+                });
+                if (response.ok) {
+                    try {
+                        const responseData = await response.json();
+                        if (responseData.status === "success") {
+                            console.log(`[Dev Mode] \u2713 Message processed successfully: topic="${topicName}" consumer="${route.consumer}" messageId="${messageId}"`);
+                        }
+                    }
+                    catch {
+                        console.warn(`[Dev Mode] Handler returned OK but response was not JSON: topic="${topicName}" consumer="${route.consumer}"`);
+                    }
+                }
+                else {
+                    try {
+                        const errorData = await response.json();
+                        console.error(`[Dev Mode] \u2717 Handler failed: topic="${topicName}" consumer="${route.consumer}" messageId="${messageId}" error="${errorData.error || response.statusText}"`);
+                    }
+                    catch {
+                        console.error(`[Dev Mode] \u2717 Handler failed: topic="${topicName}" consumer="${route.consumer}" messageId="${messageId}" status=${response.status}`);
+                    }
+                }
+            }
+            catch (error45) {
+                console.error(`[Dev Mode] \u2717 HTTP request failed: topic="${topicName}" consumer="${route.consumer}" messageId="${messageId}" url="${url2}"`, error45);
+            }
+        }
+    })();
+}
+__name(triggerDevCallbacks, "triggerDevCallbacks");
+function clearDevRouteMappings2() {
+    const g = globalThis;
+    delete g[ROUTE_MAPPINGS_KEY2];
+}
+__name(clearDevRouteMappings2, "clearDevRouteMappings");
+if (process.env.NODE_ENV === "test" || process.env.VITEST) {
+    globalThis.__clearDevRouteMappings = clearDevRouteMappings2;
+}
+async function streamToBuffer2(stream) {
+    let totalLength = 0;
+    const reader = stream.getReader();
+    const chunks = [];
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            chunks.push(value);
+            totalLength += value.length;
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+    return Buffer.concat(chunks, totalLength);
+}
+__name(streamToBuffer2, "streamToBuffer");
+var JsonTransport2 = class {
+    static {
+        __name(this, "JsonTransport");
+    }
+    contentType = "application/json";
+    replacer;
+    reviver;
+    /**
+    * Create a new JsonTransport.
+    * @param options - Optional JSON serialization options
+    * @param options.replacer - Custom replacer for JSON.stringify
+    * @param options.reviver - Custom reviver for JSON.parse
+    */
+    constructor(options = {}) {
+        this.replacer = options.replacer;
+        this.reviver = options.reviver;
+    }
+    serialize(value) {
+        return Buffer.from(JSON.stringify(value, this.replacer), "utf8");
+    }
+    async deserialize(stream) {
+        const buffer = await streamToBuffer2(stream);
+        return JSON.parse(buffer.toString("utf8"), this.reviver);
+    }
+};
+function isDebugEnabled2() {
+    return process.env.VERCEL_QUEUE_DEBUG === "1" || process.env.VERCEL_QUEUE_DEBUG === "true";
+}
+__name(isDebugEnabled2, "isDebugEnabled");
+async function consumeStream2(stream) {
+    const reader = stream.getReader();
+    try {
+        while (true) {
+            const { done } = await reader.read();
+            if (done)
+                break;
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+__name(consumeStream2, "consumeStream");
+function throwCommonHttpError2(status, statusText, errorText, operation, badRequestDefault = "Invalid parameters") {
+    if (status === 400) {
+        throw new BadRequestError2(errorText || badRequestDefault);
+    }
+    if (status === 401) {
+        throw new UnauthorizedError2(errorText || void 0);
+    }
+    if (status === 403) {
+        throw new ForbiddenError2(errorText || void 0);
+    }
+    if (status >= 500) {
+        throw new InternalServerError2(errorText || `Server error: ${status} ${statusText}`);
+    }
+    throw new Error(`Failed to ${operation}: ${status} ${statusText}`);
+}
+__name(throwCommonHttpError2, "throwCommonHttpError");
+function parseQueueHeaders2(headers) {
+    const messageId = headers.get("Vqs-Message-Id");
+    const deliveryCountStr = headers.get("Vqs-Delivery-Count") || "0";
+    const timestamp = headers.get("Vqs-Timestamp");
+    const contentType = headers.get("Content-Type") || "application/octet-stream";
+    const receiptHandle = headers.get("Vqs-Receipt-Handle");
+    if (!messageId || !timestamp || !receiptHandle) {
+        return null;
+    }
+    const deliveryCount = parseInt(deliveryCountStr, 10);
+    if (Number.isNaN(deliveryCount)) {
+        return null;
+    }
+    return {
+        messageId,
+        deliveryCount,
+        createdAt: new Date(timestamp),
+        contentType,
+        receiptHandle
+    };
+}
+__name(parseQueueHeaders2, "parseQueueHeaders");
+var QueueClient2 = class {
+    static {
+        __name(this, "QueueClient");
+    }
+    baseUrl;
+    basePath;
+    customHeaders;
+    providedToken;
+    defaultDeploymentId;
+    pinToDeployment;
+    transport;
+    constructor(options = {}) {
+        this.baseUrl = options.baseUrl || process.env.VERCEL_QUEUE_BASE_URL || "https://vercel-queue.com";
+        this.basePath = options.basePath || process.env.VERCEL_QUEUE_BASE_PATH || "/api/v3/topic";
+        this.customHeaders = options.headers || {};
+        this.providedToken = options.token;
+        this.defaultDeploymentId = options.deploymentId || process.env.VERCEL_DEPLOYMENT_ID;
+        this.pinToDeployment = options.pinToDeployment ?? true;
+        this.transport = options.transport || new JsonTransport2();
+    }
+    getTransport() {
+        return this.transport;
+    }
+    getSendDeploymentId() {
+        if (isDevMode2()) {
+            return void 0;
+        }
+        if (this.pinToDeployment) {
+            return this.defaultDeploymentId;
+        }
+        return void 0;
+    }
+    getConsumeDeploymentId() {
+        if (isDevMode2()) {
+            return void 0;
+        }
+        return this.defaultDeploymentId;
+    }
+    async getToken() {
+        if (this.providedToken) {
+            return this.providedToken;
+        }
+        const token = await (0, import_oidc3.getVercelOidcToken)();
+        if (!token) {
+            throw new Error("Failed to get OIDC token from Vercel Functions. Make sure you are running in a Vercel Function environment, or provide a token explicitly.\n\nTo set up your environment:\n1. Link your project: 'vercel link'\n2. Pull environment variables: 'vercel env pull'\n3. Run with environment: 'dotenv -e .env.local -- your-command'");
+        }
+        return token;
+    }
+    buildUrl(queueName, ...pathSegments) {
+        const encodedQueue = encodeURIComponent(queueName);
+        const segments = pathSegments.map((s) => encodeURIComponent(s));
+        const path22 = segments.length > 0 ? "/" + segments.join("/") : "";
+        return `${this.baseUrl}${this.basePath}/${encodedQueue}${path22}`;
+    }
+    async fetch(url2, init) {
+        const method = init.method || "GET";
+        if (isDebugEnabled2()) {
+            const logData = {
+                method,
+                url: url2,
+                headers: init.headers
+            };
+            const body = init.body;
+            if (body !== void 0 && body !== null) {
+                if (body instanceof ArrayBuffer) {
+                    logData.bodySize = body.byteLength;
+                }
+                else if (body instanceof Uint8Array) {
+                    logData.bodySize = body.byteLength;
+                }
+                else if (typeof body === "string") {
+                    logData.bodySize = body.length;
+                }
+                else {
+                    logData.bodyType = typeof body;
+                }
+            }
+            console.debug("[VQS Debug] Request:", JSON.stringify(logData, null, 2));
+        }
+        init.headers.set("User-Agent", `@vercel/queue/${"0.0.0-alpha.38"}`);
+        init.headers.set("Vqs-Client-Ts", /* @__PURE__ */ ( /* @__PURE__ */new Date()).toISOString());
+        const response = await fetch(url2, init);
+        if (isDebugEnabled2()) {
+            const logData = {
+                method,
+                url: url2,
+                status: response.status,
+                statusText: response.statusText,
+                headers: response.headers
+            };
+            console.debug("[VQS Debug] Response:", JSON.stringify(logData, null, 2));
+        }
+        return response;
+    }
+    /**
+    * Send a message to a topic.
+    *
+    * @param options - Message options including queue name, payload, and optional settings
+    * @param options.queueName - Topic name (pattern: `[A-Za-z0-9_-]+`)
+    * @param options.payload - Message payload
+    * @param options.idempotencyKey - Optional deduplication key (dedup window: min(retention, 24h))
+    * @param options.retentionSeconds - Message TTL (default: 86400, min: 60, max: 86400)
+    * @param options.delaySeconds - Delivery delay (default: 0, max: retentionSeconds)
+    * @returns Promise with the generated messageId
+    * @throws {DuplicateMessageError} When idempotency key was already used
+    * @throws {ConsumerDiscoveryError} When consumer discovery fails
+    * @throws {ConsumerRegistryNotConfiguredError} When registry not configured
+    * @throws {BadRequestError} When parameters are invalid
+    * @throws {UnauthorizedError} When authentication fails
+    * @throws {ForbiddenError} When access is denied
+    * @throws {InternalServerError} When server encounters an error
+    */
+    async sendMessage(options) {
+        const transport = this.transport;
+        const { queueName, payload, idempotencyKey, retentionSeconds, delaySeconds, headers: optionHeaders } = options;
+        const headers = new Headers();
+        if (this.customHeaders) {
+            for (const [name, value] of Object.entries(this.customHeaders)) {
+                headers.append(name, value);
+            }
+        }
+        if (optionHeaders) {
+            const protectedHeaderNames = /* @__PURE__ */ new Set([
+                "authorization",
+                "content-type"
+            ]);
+            const isProtectedHeader = /* @__PURE__ */ __name((name) => {
+                const lower = name.toLowerCase();
+                if (protectedHeaderNames.has(lower))
+                    return true;
+                return lower.startsWith("vqs-");
+            }, "isProtectedHeader");
+            for (const [name, value] of Object.entries(optionHeaders)) {
+                if (!isProtectedHeader(name) && value !== void 0) {
+                    headers.append(name, value);
+                }
+            }
+        }
+        headers.set("Authorization", `Bearer ${await this.getToken()}`);
+        headers.set("Content-Type", transport.contentType);
+        const deploymentId = this.getSendDeploymentId();
+        if (deploymentId) {
+            headers.set("Vqs-Deployment-Id", deploymentId);
+        }
+        if (idempotencyKey) {
+            headers.set("Vqs-Idempotency-Key", idempotencyKey);
+        }
+        if (retentionSeconds !== void 0) {
+            headers.set("Vqs-Retention-Seconds", retentionSeconds.toString());
+        }
+        if (delaySeconds !== void 0) {
+            headers.set("Vqs-Delay-Seconds", delaySeconds.toString());
+        }
+        const serialized = transport.serialize(payload);
+        const body = Buffer.isBuffer(serialized) ? new Uint8Array(serialized) : serialized;
+        const response = await this.fetch(this.buildUrl(queueName), {
+            method: "POST",
+            body,
+            headers
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            if (response.status === 409) {
+                throw new DuplicateMessageError2(errorText || "Duplicate idempotency key detected", idempotencyKey);
+            }
+            if (response.status === 502) {
+                throw new ConsumerDiscoveryError2(errorText || "Consumer discovery failed", deploymentId);
+            }
+            if (response.status === 503) {
+                throw new ConsumerRegistryNotConfiguredError2(errorText || "Consumer registry not configured");
+            }
+            throwCommonHttpError2(response.status, response.statusText, errorText, "send message");
+        }
+        const responseData = await response.json();
+        return responseData;
+    }
+    /**
+    * Receive messages from a topic as an async generator.
+    *
+    * When the queue is empty, the generator completes without yielding any
+    * messages. Callers should handle the case where no messages are yielded.
+    *
+    * @param options - Receive options
+    * @param options.queueName - Topic name (pattern: `[A-Za-z0-9_-]+`)
+    * @param options.consumerGroup - Consumer group name (pattern: `[A-Za-z0-9_-]+`)
+    * @param options.visibilityTimeoutSeconds - Lock duration (default: 30, min: 0, max: 3600)
+    * @param options.limit - Max messages to retrieve (default: 1, min: 1, max: 10)
+    * @yields Message objects with payload, messageId, receiptHandle, etc.
+    *         Yields nothing if queue is empty.
+    * @throws {InvalidLimitError} When limit is outside 1-10 range
+    * @throws {BadRequestError} When parameters are invalid
+    * @throws {UnauthorizedError} When authentication fails
+    * @throws {ForbiddenError} When access is denied
+    * @throws {InternalServerError} When server encounters an error
+    */
+    async *receiveMessages(options) {
+        const transport = this.transport;
+        const { queueName, consumerGroup, visibilityTimeoutSeconds, limit } = options;
+        if (limit !== void 0 && (limit < 1 || limit > 10)) {
+            throw new InvalidLimitError2(limit);
+        }
+        const headers = new Headers({
+            Authorization: `Bearer ${await this.getToken()}`,
+            Accept: "multipart/mixed",
+            ...this.customHeaders
+        });
+        if (visibilityTimeoutSeconds !== void 0) {
+            headers.set("Vqs-Visibility-Timeout-Seconds", visibilityTimeoutSeconds.toString());
+        }
+        if (limit !== void 0) {
+            headers.set("Vqs-Max-Messages", limit.toString());
+        }
+        const effectiveDeploymentId = this.getConsumeDeploymentId();
+        if (effectiveDeploymentId) {
+            headers.set("Vqs-Deployment-Id", effectiveDeploymentId);
+        }
+        const response = await this.fetch(this.buildUrl(queueName, "consumer", consumerGroup), {
+            method: "POST",
+            headers
+        });
+        if (response.status === 204) {
+            return;
+        }
+        if (!response.ok) {
+            const errorText = await response.text();
+            throwCommonHttpError2(response.status, response.statusText, errorText, "receive messages");
+        }
+        for await (const multipartMessage of parseMultipartStream(response)) {
+            try {
+                const parsedHeaders = parseQueueHeaders2(multipartMessage.headers);
+                if (!parsedHeaders) {
+                    console.warn("Missing required queue headers in multipart part");
+                    await consumeStream2(multipartMessage.payload);
+                    continue;
+                }
+                const deserializedPayload = await transport.deserialize(multipartMessage.payload);
+                const message = {
+                    ...parsedHeaders,
+                    payload: deserializedPayload
+                };
+                yield message;
+            }
+            catch (error45) {
+                console.warn("Failed to process multipart message:", error45);
+                await consumeStream2(multipartMessage.payload);
+            }
+        }
+    }
+    /**
+    * Receive a specific message by its ID.
+    *
+    * @param options - Receive options
+    * @param options.queueName - Topic name (pattern: `[A-Za-z0-9_-]+`)
+    * @param options.consumerGroup - Consumer group name (pattern: `[A-Za-z0-9_-]+`)
+    * @param options.messageId - Message ID to retrieve
+    * @param options.visibilityTimeoutSeconds - Lock duration (default: 30, min: 0, max: 3600)
+    * @returns Promise with the message
+    * @throws {MessageNotFoundError} When message doesn't exist
+    * @throws {MessageNotAvailableError} When message is in wrong state or was a duplicate
+    * @throws {MessageAlreadyProcessedError} When message was already processed
+    * @throws {BadRequestError} When parameters are invalid
+    * @throws {UnauthorizedError} When authentication fails
+    * @throws {ForbiddenError} When access is denied
+    * @throws {InternalServerError} When server encounters an error
+    */
+    async receiveMessageById(options) {
+        const transport = this.transport;
+        const { queueName, consumerGroup, messageId, visibilityTimeoutSeconds } = options;
+        const headers = new Headers({
+            Authorization: `Bearer ${await this.getToken()}`,
+            Accept: "multipart/mixed",
+            ...this.customHeaders
+        });
+        if (visibilityTimeoutSeconds !== void 0) {
+            headers.set("Vqs-Visibility-Timeout-Seconds", visibilityTimeoutSeconds.toString());
+        }
+        const effectiveDeploymentId = this.getConsumeDeploymentId();
+        if (effectiveDeploymentId) {
+            headers.set("Vqs-Deployment-Id", effectiveDeploymentId);
+        }
+        const response = await this.fetch(this.buildUrl(queueName, "consumer", consumerGroup, "id", messageId), {
+            method: "POST",
+            headers
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            if (response.status === 404) {
+                throw new MessageNotFoundError2(messageId);
+            }
+            if (response.status === 409) {
+                let errorData = {};
+                try {
+                    errorData = JSON.parse(errorText);
+                }
+                catch {
+                }
+                if (errorData.originalMessageId) {
+                    throw new MessageNotAvailableError2(messageId, `This message was a duplicate - use originalMessageId: ${errorData.originalMessageId}`);
+                }
+                throw new MessageNotAvailableError2(messageId);
+            }
+            if (response.status === 410) {
+                throw new MessageAlreadyProcessedError2(messageId);
+            }
+            throwCommonHttpError2(response.status, response.statusText, errorText, "receive message by ID");
+        }
+        for await (const multipartMessage of parseMultipartStream(response)) {
+            const parsedHeaders = parseQueueHeaders2(multipartMessage.headers);
+            if (!parsedHeaders) {
+                await consumeStream2(multipartMessage.payload);
+                throw new MessageCorruptedError2(messageId, "Missing required queue headers in response");
+            }
+            const deserializedPayload = await transport.deserialize(multipartMessage.payload);
+            const message = {
+                ...parsedHeaders,
+                payload: deserializedPayload
+            };
+            return {
+                message
+            };
+        }
+        throw new MessageNotFoundError2(messageId);
+    }
+    /**
+    * Delete (acknowledge) a message after successful processing.
+    *
+    * @param options - Delete options
+    * @param options.queueName - Topic name
+    * @param options.consumerGroup - Consumer group name
+    * @param options.receiptHandle - Receipt handle from the received message (must use same deployment ID as receive)
+    * @returns Promise indicating deletion success
+    * @throws {MessageNotFoundError} When receipt handle not found
+    * @throws {MessageNotAvailableError} When receipt handle invalid or message already processed
+    * @throws {BadRequestError} When parameters are invalid
+    * @throws {UnauthorizedError} When authentication fails
+    * @throws {ForbiddenError} When access is denied
+    * @throws {InternalServerError} When server encounters an error
+    */
+    async deleteMessage(options) {
+        const { queueName, consumerGroup, receiptHandle } = options;
+        const headers = new Headers({
+            Authorization: `Bearer ${await this.getToken()}`,
+            ...this.customHeaders
+        });
+        const effectiveDeploymentId = this.getConsumeDeploymentId();
+        if (effectiveDeploymentId) {
+            headers.set("Vqs-Deployment-Id", effectiveDeploymentId);
+        }
+        const response = await this.fetch(this.buildUrl(queueName, "consumer", consumerGroup, "lease", receiptHandle), {
+            method: "DELETE",
+            headers
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            if (response.status === 404) {
+                throw new MessageNotFoundError2(receiptHandle);
+            }
+            if (response.status === 409) {
+                throw new MessageNotAvailableError2(receiptHandle, errorText || "Invalid receipt handle, message not in correct state, or already processed");
+            }
+            throwCommonHttpError2(response.status, response.statusText, errorText, "delete message", "Missing or invalid receipt handle");
+        }
+        return {
+            deleted: true
+        };
+    }
+    /**
+    * Extend or change the visibility timeout of a message.
+    * Used to prevent message redelivery while still processing.
+    *
+    * @param options - Visibility options
+    * @param options.queueName - Topic name
+    * @param options.consumerGroup - Consumer group name
+    * @param options.receiptHandle - Receipt handle from the received message (must use same deployment ID as receive)
+    * @param options.visibilityTimeoutSeconds - New timeout (min: 0, max: 3600, cannot exceed message expiration)
+    * @returns Promise indicating success
+    * @throws {MessageNotFoundError} When receipt handle not found
+    * @throws {MessageNotAvailableError} When receipt handle invalid or message already processed
+    * @throws {BadRequestError} When parameters are invalid
+    * @throws {UnauthorizedError} When authentication fails
+    * @throws {ForbiddenError} When access is denied
+    * @throws {InternalServerError} When server encounters an error
+    */
+    async changeVisibility(options) {
+        const { queueName, consumerGroup, receiptHandle, visibilityTimeoutSeconds } = options;
+        const headers = new Headers({
+            Authorization: `Bearer ${await this.getToken()}`,
+            "Content-Type": "application/json",
+            ...this.customHeaders
+        });
+        const effectiveDeploymentId = this.getConsumeDeploymentId();
+        if (effectiveDeploymentId) {
+            headers.set("Vqs-Deployment-Id", effectiveDeploymentId);
+        }
+        const response = await this.fetch(this.buildUrl(queueName, "consumer", consumerGroup, "lease", receiptHandle), {
+            method: "PATCH",
+            headers,
+            body: JSON.stringify({
+                visibilityTimeoutSeconds
+            })
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            if (response.status === 404) {
+                throw new MessageNotFoundError2(receiptHandle);
+            }
+            if (response.status === 409) {
+                throw new MessageNotAvailableError2(receiptHandle, errorText || "Invalid receipt handle, message not in correct state, or already processed");
+            }
+            throwCommonHttpError2(response.status, response.statusText, errorText, "change visibility", "Missing receipt handle or invalid visibility timeout");
+        }
+        return {
+            success: true
+        };
+    }
+    /**
+    * Alternative endpoint for changing message visibility timeout.
+    * Uses the /visibility path suffix and expects visibilityTimeoutSeconds in the body.
+    * Functionally equivalent to changeVisibility but follows an alternative API pattern.
+    *
+    * @param options - Options for changing visibility
+    * @returns Promise resolving to change visibility response
+    */
+    async changeVisibilityAlt(options) {
+        const { queueName, consumerGroup, receiptHandle, visibilityTimeoutSeconds } = options;
+        const headers = new Headers({
+            Authorization: `Bearer ${await this.getToken()}`,
+            "Content-Type": "application/json",
+            ...this.customHeaders
+        });
+        const effectiveDeploymentId = this.getConsumeDeploymentId();
+        if (effectiveDeploymentId) {
+            headers.set("Vqs-Deployment-Id", effectiveDeploymentId);
+        }
+        const response = await this.fetch(this.buildUrl(queueName, "consumer", consumerGroup, "lease", receiptHandle, "visibility"), {
+            method: "PATCH",
+            headers,
+            body: JSON.stringify({
+                visibilityTimeoutSeconds
+            })
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            if (response.status === 404) {
+                throw new MessageNotFoundError2(receiptHandle);
+            }
+            if (response.status === 409) {
+                throw new MessageNotAvailableError2(receiptHandle, errorText || "Invalid receipt handle, message not in correct state, or already processed");
+            }
+            throwCommonHttpError2(response.status, response.statusText, errorText, "change visibility (alt)", "Missing receipt handle or invalid visibility timeout");
+        }
+        return {
+            success: true
+        };
+    }
+};
+var DEFAULT_VISIBILITY_TIMEOUT_SECONDS = 300;
+var MIN_VISIBILITY_TIMEOUT_SECONDS = 30;
+var MAX_RENEWAL_INTERVAL_SECONDS = 60;
+var MIN_RENEWAL_INTERVAL_SECONDS = 10;
+var RETRY_INTERVAL_MS = 3e3;
+function calculateRenewalInterval(visibilityTimeoutSeconds) {
+    return Math.min(MAX_RENEWAL_INTERVAL_SECONDS, Math.max(MIN_RENEWAL_INTERVAL_SECONDS, visibilityTimeoutSeconds / 5));
+}
+__name(calculateRenewalInterval, "calculateRenewalInterval");
+var ConsumerGroup = class {
+    static {
+        __name(this, "ConsumerGroup");
+    }
+    client;
+    topicName;
+    consumerGroupName;
+    visibilityTimeout;
+    /**
+    * Create a new ConsumerGroup instance.
+    *
+    * @param client - QueueClient instance to use for API calls (transport is configured on the client)
+    * @param topicName - Name of the topic to consume from (pattern: `[A-Za-z0-9_-]+`)
+    * @param consumerGroupName - Name of the consumer group (pattern: `[A-Za-z0-9_-]+`)
+    * @param options - Optional configuration
+    * @param options.visibilityTimeoutSeconds - Message lock duration (default: 300, max: 3600)
+    */
+    constructor(client, topicName, consumerGroupName, options = {}) {
+        this.client = client;
+        this.topicName = topicName;
+        this.consumerGroupName = consumerGroupName;
+        this.visibilityTimeout = Math.max(MIN_VISIBILITY_TIMEOUT_SECONDS, options.visibilityTimeoutSeconds ?? DEFAULT_VISIBILITY_TIMEOUT_SECONDS);
+    }
+    /**
+    * Check if an error is a 4xx client error that should stop retries.
+    * 4xx errors indicate the request is fundamentally invalid and retrying won't help.
+    * - 409: Ticket mismatch (lost ownership to another consumer)
+    * - 404: Message/receipt handle not found
+    * - 400, 401, 403: Other client errors
+    */
+    isClientError(error45) {
+        return error45 instanceof MessageNotAvailableError2 || // 409 - ticket mismatch, lost ownership
+            error45 instanceof MessageNotFoundError2 || // 404 - receipt handle not found
+            error45 instanceof BadRequestError2 || // 400 - invalid parameters
+            error45 instanceof UnauthorizedError2 || // 401 - auth failed
+            error45 instanceof ForbiddenError2;
+    }
+    /**
+    * Starts a background loop that periodically extends the visibility timeout for a message.
+    *
+    * Timing strategy:
+    * - Renewal interval: min(60s, max(10s, visibilityTimeout/5))
+    * - Extensions request the same duration as the initial visibility timeout
+    * - When `visibilityDeadline` is provided (binary mode small body), the first
+    *   extension delay is calculated from the time remaining until the deadline
+    *   using the same renewal formula, ensuring the first extension fires before
+    *   the server-assigned lease expires. Subsequent renewals use the standard interval.
+    *
+    * Retry strategy:
+    * - On transient failures (5xx, network errors): retry every 3 seconds
+    * - On 4xx client errors: stop retrying (the lease is lost or invalid)
+    *
+    * @param receiptHandle - The receipt handle to extend visibility for
+    * @param options - Optional configuration
+    * @param options.visibilityDeadline - Absolute deadline (from server's `ce-vqsvisibilitydeadline`)
+    *   when the current visibility timeout expires. Used to calculate the first extension delay.
+    */
+    startVisibilityExtension(receiptHandle, options) {
+        let isRunning = true;
+        let isResolved = false;
+        let resolveLifecycle;
+        let timeoutId = null;
+        const renewalIntervalMs = calculateRenewalInterval(this.visibilityTimeout) * 1e3;
+        let firstDelayMs = renewalIntervalMs;
+        if (options?.visibilityDeadline) {
+            const timeRemainingMs = options.visibilityDeadline.getTime() - Date.now();
+            if (timeRemainingMs > 0) {
+                const timeRemainingSeconds = timeRemainingMs / 1e3;
+                firstDelayMs = calculateRenewalInterval(timeRemainingSeconds) * 1e3;
+            }
+            else {
+                firstDelayMs = 0;
+            }
+        }
+        const lifecyclePromise = new Promise((resolve2) => {
+            resolveLifecycle = resolve2;
+        });
+        const safeResolve = /* @__PURE__ */ __name(() => {
+            if (!isResolved) {
+                isResolved = true;
+                resolveLifecycle();
+            }
+        }, "safeResolve");
+        const extend2 = /* @__PURE__ */ __name(async () => {
+            if (!isRunning) {
+                safeResolve();
+                return;
+            }
+            try {
+                await this.client.changeVisibility({
+                    queueName: this.topicName,
+                    consumerGroup: this.consumerGroupName,
+                    receiptHandle,
+                    visibilityTimeoutSeconds: this.visibilityTimeout
+                });
+                if (isRunning) {
+                    timeoutId = setTimeout(() => extend2(), renewalIntervalMs);
+                }
+                else {
+                    safeResolve();
+                }
+            }
+            catch (error45) {
+                if (this.isClientError(error45)) {
+                    console.error(`Visibility extension failed with client error for receipt handle ${receiptHandle} (stopping retries):`, error45);
+                    safeResolve();
+                    return;
+                }
+                console.error(`Failed to extend visibility for receipt handle ${receiptHandle} (will retry in ${RETRY_INTERVAL_MS / 1e3}s):`, error45);
+                if (isRunning) {
+                    timeoutId = setTimeout(() => extend2(), RETRY_INTERVAL_MS);
+                }
+                else {
+                    safeResolve();
+                }
+            }
+        }, "extend");
+        timeoutId = setTimeout(() => extend2(), firstDelayMs);
+        return async (waitForCompletion = false) => {
+            isRunning = false;
+            if (timeoutId) {
+                clearTimeout(timeoutId);
+                timeoutId = null;
+            }
+            if (waitForCompletion) {
+                await lifecyclePromise;
+            }
+            else {
+                safeResolve();
+            }
+        };
+    }
+    async processMessage(message, handler, options) {
+        const stopExtension = this.startVisibilityExtension(message.receiptHandle, options);
+        try {
+            await handler(message.payload, {
+                messageId: message.messageId,
+                deliveryCount: message.deliveryCount,
+                createdAt: message.createdAt,
+                topicName: this.topicName,
+                consumerGroup: this.consumerGroupName
+            });
+            await stopExtension();
+            await this.client.deleteMessage({
+                queueName: this.topicName,
+                consumerGroup: this.consumerGroupName,
+                receiptHandle: message.receiptHandle
+            });
+        }
+        catch (error45) {
+            await stopExtension();
+            const transport = this.client.getTransport();
+            if (transport.finalize && message.payload !== void 0 && message.payload !== null) {
+                try {
+                    await transport.finalize(message.payload);
+                }
+                catch (finalizeError) {
+                    console.warn("Failed to finalize message payload:", finalizeError);
+                }
+            }
+            throw error45;
+        }
+    }
+    /**
+    * Process a pre-fetched message directly, without calling `receiveMessageById`.
+    *
+    * Used by the binary mode (v2beta) small body fast path, where the server
+    * pushes the full message payload in the callback request. The message is
+    * processed with the same lifecycle guarantees as `consume()`:
+    * - Visibility timeout is extended periodically during processing
+    * - Message is deleted on successful handler completion
+    * - Payload is finalized on error if the transport supports it
+    *
+    * @param handler - Function to process the message payload and metadata
+    * @param message - The complete message including payload and receipt handle
+    * @param options - Optional configuration
+    * @param options.visibilityDeadline - Absolute deadline when the server-assigned
+    *   visibility timeout expires (from `ce-vqsvisibilitydeadline`). Used to
+    *   schedule the first visibility extension before the lease expires.
+    */
+    async consumeMessage(handler, message, options) {
+        await this.processMessage(message, handler, options);
+    }
+    async consume(handler, options) {
+        if (options && "messageId" in options) {
+            const response = await this.client.receiveMessageById({
+                queueName: this.topicName,
+                consumerGroup: this.consumerGroupName,
+                messageId: options.messageId,
+                visibilityTimeoutSeconds: this.visibilityTimeout
+            });
+            await this.processMessage(response.message, handler);
+        }
+        else {
+            const limit = options && "limit" in options ? options.limit : 1;
+            let messageFound = false;
+            for await (const message of this.client.receiveMessages({
+                queueName: this.topicName,
+                consumerGroup: this.consumerGroupName,
+                visibilityTimeoutSeconds: this.visibilityTimeout,
+                limit
+            })) {
+                messageFound = true;
+                await this.processMessage(message, handler);
             }
-            return result;
-        }, "list")
-    };
-}
-__name(createStepsStorage, "createStepsStorage");
-// ../world-local/dist/storage/index.js
-function createStorage(basedir) {
-    const storage = {
-        runs: createRunsStorage(basedir),
-        steps: createStepsStorage(basedir),
-        events: createEventsStorage(basedir),
-        hooks: createHooksStorage(basedir)
-    };
-    return {
-        runs: instrumentObject("world.runs", storage.runs),
-        steps: instrumentObject("world.steps", storage.steps),
-        events: instrumentObject("world.events", storage.events),
-        hooks: instrumentObject("world.hooks", storage.hooks)
-    };
+            if (!messageFound) {
+                await handler(null, null);
+            }
+        }
+    }
+    /**
+    * Get the consumer group name
+    */
+    get name() {
+        return this.consumerGroupName;
+    }
+    /**
+    * Get the topic name this consumer group is subscribed to
+    */
+    get topic() {
+        return this.topicName;
+    }
+};
+var Topic = class {
+    static {
+        __name(this, "Topic");
+    }
+    client;
+    topicName;
+    /**
+    * Create a new Topic instance
+    * @param client QueueClient instance to use for API calls (transport is configured on the client)
+    * @param topicName Name of the topic to work with
+    */
+    constructor(client, topicName) {
+        this.client = client;
+        this.topicName = topicName;
+    }
+    /**
+    * Publish a message to the topic
+    * @param payload The data to publish
+    * @param options Optional publish options
+    * @returns An object containing the message ID
+    * @throws {BadRequestError} When request parameters are invalid
+    * @throws {UnauthorizedError} When authentication fails
+    * @throws {ForbiddenError} When access is denied (environment mismatch)
+    * @throws {InternalServerError} When server encounters an error
+    */
+    async publish(payload, options) {
+        const result = await this.client.sendMessage({
+            queueName: this.topicName,
+            payload,
+            idempotencyKey: options?.idempotencyKey,
+            retentionSeconds: options?.retentionSeconds,
+            delaySeconds: options?.delaySeconds,
+            headers: options?.headers
+        });
+        if (isDevMode2()) {
+            triggerDevCallbacks(this.topicName, result.messageId);
+        }
+        return {
+            messageId: result.messageId
+        };
+    }
+    /**
+    * Create a consumer group for this topic
+    * @param consumerGroupName Name of the consumer group
+    * @param options Optional configuration for the consumer group
+    * @returns A ConsumerGroup instance
+    */
+    consumerGroup(consumerGroupName, options) {
+        return new ConsumerGroup(this.client, this.topicName, consumerGroupName, options);
+    }
+    /**
+    * Get the topic name
+    */
+    get name() {
+        return this.topicName;
+    }
+};
+var CLOUD_EVENT_TYPE_V1BETA = "com.vercel.queue.v1beta";
+var CLOUD_EVENT_TYPE_V2BETA = "com.vercel.queue.v2beta";
+function matchesWildcardPattern(topicName, pattern) {
+    const prefix = pattern.slice(0, -1);
+    return topicName.startsWith(prefix);
 }
-__name(createStorage, "createStorage");
-// ../world-local/dist/streamer.js
-var import_node_events = require("node:events");
-var import_node_path8 = __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
-    ]);
-    return Buffer.concat([
-        eofByte,
-        chunk.chunk
-    ]);
+__name(matchesWildcardPattern, "matchesWildcardPattern");
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
 }
-__name(serializeChunk, "serializeChunk");
-function deserializeChunk(serialized) {
-    const eof = serialized[0] === 1;
-    const chunk = Buffer.from(serialized.subarray(1));
+__name(isRecord, "isRecord");
+function parseV1StructuredBody(body, contentType) {
+    if (!contentType || !contentType.includes("application/cloudevents+json")) {
+        throw new Error("Invalid content type: expected 'application/cloudevents+json'");
+    }
+    if (!isRecord(body) || !body.type || !body.source || !body.id || !isRecord(body.data)) {
+        throw new Error("Invalid CloudEvent: missing required fields");
+    }
+    if (body.type !== CLOUD_EVENT_TYPE_V1BETA) {
+        throw new Error(`Invalid CloudEvent type: expected '${CLOUD_EVENT_TYPE_V1BETA}', got '${String(body.type)}'`);
+    }
+    const { data } = body;
+    const missingFields = [];
+    if (!("queueName" in data))
+        missingFields.push("queueName");
+    if (!("consumerGroup" in data))
+        missingFields.push("consumerGroup");
+    if (!("messageId" in data))
+        missingFields.push("messageId");
+    if (missingFields.length > 0) {
+        throw new Error(`Missing required CloudEvent data fields: ${missingFields.join(", ")}`);
+    }
     return {
-        eof,
-        chunk
+        queueName: String(data.queueName),
+        consumerGroup: String(data.consumerGroup),
+        messageId: String(data.messageId)
+    };
+}
+__name(parseV1StructuredBody, "parseV1StructuredBody");
+function getHeader(headers, name) {
+    if (headers instanceof Headers) {
+        return headers.get(name);
+    }
+    const value = headers[name];
+    if (Array.isArray(value))
+        return value[0] ?? null;
+    return value ?? null;
+}
+__name(getHeader, "getHeader");
+function parseBinaryHeaders(headers) {
+    const ceType = getHeader(headers, "ce-type");
+    if (ceType !== CLOUD_EVENT_TYPE_V2BETA) {
+        throw new Error(`Invalid CloudEvent type: expected '${CLOUD_EVENT_TYPE_V2BETA}', got '${ceType}'`);
+    }
+    const queueName = getHeader(headers, "ce-vqsqueuename");
+    const consumerGroup = getHeader(headers, "ce-vqsconsumergroup");
+    const messageId = getHeader(headers, "ce-vqsmessageid");
+    const missingFields = [];
+    if (!queueName)
+        missingFields.push("ce-vqsqueuename");
+    if (!consumerGroup)
+        missingFields.push("ce-vqsconsumergroup");
+    if (!messageId)
+        missingFields.push("ce-vqsmessageid");
+    if (missingFields.length > 0) {
+        throw new Error(`Missing required CloudEvent headers: ${missingFields.join(", ")}`);
+    }
+    const base = {
+        queueName,
+        consumerGroup,
+        messageId
+    };
+    const receiptHandle = getHeader(headers, "ce-vqsreceipthandle");
+    if (!receiptHandle) {
+        return base;
+    }
+    const result = {
+        ...base,
+        receiptHandle
     };
+    const deliveryCount = getHeader(headers, "ce-vqsdeliverycount");
+    if (deliveryCount) {
+        result.deliveryCount = parseInt(deliveryCount, 10);
+    }
+    const createdAt = getHeader(headers, "ce-vqscreatedat");
+    if (createdAt) {
+        result.createdAt = createdAt;
+    }
+    const contentType = getHeader(headers, "content-type");
+    if (contentType) {
+        result.contentType = contentType;
+    }
+    const visibilityDeadline = getHeader(headers, "ce-vqsvisibilitydeadline");
+    if (visibilityDeadline) {
+        result.visibilityDeadline = visibilityDeadline;
+    }
+    return result;
 }
-__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_path8.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
-            });
+__name(parseBinaryHeaders, "parseBinaryHeaders");
+function parseRawCallback(body, headers) {
+    const ceType = getHeader(headers, "ce-type");
+    if (ceType === CLOUD_EVENT_TYPE_V2BETA) {
+        const result = parseBinaryHeaders(headers);
+        if ("receiptHandle" in result) {
+            result.parsedPayload = body;
         }
-        registeredStreams.add(cacheKey);
+        return result;
     }
-    __name(registerStreamForRun, "registerStreamForRun");
-    function toBuffer(chunk) {
-        if (typeof chunk === "string") {
-            return Buffer.from(new TextEncoder().encode(chunk));
+    return parseV1StructuredBody(body, getHeader(headers, "content-type"));
+}
+__name(parseRawCallback, "parseRawCallback");
+async function parseCallback(request) {
+    const ceType = request.headers.get("ce-type");
+    if (ceType === CLOUD_EVENT_TYPE_V2BETA) {
+        const result = parseBinaryHeaders(request.headers);
+        if ("receiptHandle" in result && request.body) {
+            result.rawBody = request.body;
         }
-        else if (chunk instanceof Buffer) {
-            return chunk;
+        return result;
+    }
+    let body;
+    try {
+        body = await request.json();
+    }
+    catch {
+        throw new Error("Failed to parse CloudEvent from request body");
+    }
+    const headers = {};
+    request.headers.forEach((value, key) => {
+        headers[key] = value;
+    });
+    return parseRawCallback(body, headers);
+}
+__name(parseCallback, "parseCallback");
+async function handleCallback(handler, request, options) {
+    const { queueName, consumerGroup, messageId } = request;
+    const client = options?.client || new QueueClient2();
+    const topic = new Topic(client, queueName);
+    const cg = topic.consumerGroup(consumerGroup, options?.visibilityTimeoutSeconds !== void 0 ? {
+        visibilityTimeoutSeconds: options.visibilityTimeoutSeconds
+    } : void 0);
+    if ("receiptHandle" in request) {
+        const transport = client.getTransport();
+        let payload;
+        if (request.rawBody) {
+            payload = await transport.deserialize(request.rawBody);
+        }
+        else if (request.parsedPayload !== void 0) {
+            payload = request.parsedPayload;
         }
         else {
-            return Buffer.from(chunk);
+            throw new Error("Binary mode callback with receipt handle is missing payload");
         }
+        const message = {
+            messageId,
+            payload,
+            deliveryCount: request.deliveryCount ?? 1,
+            createdAt: request.createdAt ? new Date(request.createdAt) : /* @__PURE__ */ new Date(),
+            contentType: request.contentType ?? transport.contentType,
+            receiptHandle: request.receiptHandle
+        };
+        const visibilityDeadline = request.visibilityDeadline ? new Date(request.visibilityDeadline) : void 0;
+        await cg.consumeMessage(handler, message, {
+            visibilityDeadline
+        });
     }
-    __name(toBuffer, "toBuffer");
-    return {
-        async writeToStream(name, _runId, chunk) {
-            const chunkId = `chnk_${monotonicUlid2()}`;
-            const runId = await _runId;
-            await registerStreamForRun(runId, name);
-            const chunkBuffer = toBuffer(chunk);
-            const serialized = serializeChunk({
-                chunk: chunkBuffer,
-                eof: false
-            });
-            const chunkPath = import_node_path8.default.join(basedir, "streams", "chunks", `${name}-${chunkId}.bin`);
-            await write(chunkPath, serialized);
-            const chunkData = Uint8Array.from(chunkBuffer);
-            streamEmitter.emit(`chunk:${name}`, {
-                streamName: name,
-                chunkData,
-                chunkId
-            });
-        },
-        async writeToStreamMulti(name, _runId, chunks) {
-            if (chunks.length === 0)
-                return;
-            const chunkIds = chunks.map(() => `chnk_${monotonicUlid2()}`);
-            const runId = await _runId;
-            await registerStreamForRun(runId, name);
-            const chunkBuffers = chunks.map((chunk) => toBuffer(chunk));
-            const writePromises = chunkBuffers.map(async (chunkBuffer, i) => {
-                const chunkId = chunkIds[i];
-                const serialized = serializeChunk({
-                    chunk: chunkBuffer,
-                    eof: false
-                });
-                const chunkPath = import_node_path8.default.join(basedir, "streams", "chunks", `${name}-${chunkId}.bin`);
-                await write(chunkPath, serialized);
-                return {
-                    chunkId,
-                    chunkData: Uint8Array.from(chunkBuffer)
-                };
+    else {
+        await cg.consume(handler, {
+            messageId
+        });
+    }
+}
+__name(handleCallback, "handleCallback");
+function handleCallback2(handler, options) {
+    return async (request) => {
+        try {
+            const parsed = await parseCallback(request);
+            await handleCallback(handler, parsed, options);
+            return Response.json({
+                status: "success"
             });
-            for (const writePromise of writePromises) {
-                const { chunkId, chunkData } = await writePromise;
-                streamEmitter.emit(`chunk:${name}`, {
-                    streamName: name,
-                    chunkData,
-                    chunkId
+        }
+        catch (error45) {
+            console.error("Queue callback error:", error45);
+            if (error45 instanceof Error && (error45.message.includes("Invalid content type") || error45.message.includes("Invalid CloudEvent") || error45.message.includes("Missing required CloudEvent") || error45.message.includes("Failed to parse CloudEvent") || error45.message.includes("Binary mode callback"))) {
+                return Response.json({
+                    error: error45.message
+                }, {
+                    status: 400
                 });
             }
-        },
-        async closeStream(name, _runId) {
-            const chunkId = `chnk_${monotonicUlid2()}`;
-            const runId = await _runId;
-            await registerStreamForRun(runId, name);
-            const chunkPath = import_node_path8.default.join(basedir, "streams", "chunks", `${name}-${chunkId}.bin`);
-            await write(chunkPath, serializeChunk({
-                chunk: Buffer.from([]),
-                eof: true
-            }));
-            streamEmitter.emit(`close:${name}`, {
-                streamName: name
-            });
-        },
-        async listStreamsByRunId(runId) {
-            const runStreamsPath = import_node_path8.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_path8.default.join(basedir, "streams", "chunks");
-            let removeListeners = /* @__PURE__ */ __name(() => {
-            }, "removeListeners");
-            return new ReadableStream({
-                async start(controller) {
-                    const deliveredChunkIds = /* @__PURE__ */ new Set();
-                    const bufferedEventChunks = [];
-                    let isReadingFromDisk = true;
-                    let pendingClose = false;
-                    const chunkListener = /* @__PURE__ */ __name((event) => {
-                        deliveredChunkIds.add(event.chunkId);
-                        if (event.chunkData.byteLength === 0) {
-                            return;
-                        }
-                        if (isReadingFromDisk) {
-                            bufferedEventChunks.push({
-                                chunkId: event.chunkId,
-                                chunkData: Uint8Array.from(event.chunkData)
-                            });
-                        }
-                        else {
-                            controller.enqueue(Uint8Array.from(event.chunkData));
-                        }
-                    }, "chunkListener");
-                    const closeListener = /* @__PURE__ */ __name(() => {
-                        if (isReadingFromDisk) {
-                            pendingClose = true;
-                            return;
-                        }
-                        streamEmitter.off(`chunk:${name}`, chunkListener);
-                        streamEmitter.off(`close:${name}`, closeListener);
-                        try {
-                            controller.close();
-                        }
-                        catch {
-                        }
-                    }, "closeListener");
-                    removeListeners = closeListener;
-                    streamEmitter.on(`chunk:${name}`, chunkListener);
-                    streamEmitter.on(`close:${name}`, closeListener);
-                    const [binFiles, jsonFiles] = await Promise.all([
-                        listFilesByExtension(chunksDir, ".bin"),
-                        listFilesByExtension(chunksDir, ".json")
-                    ]);
-                    const fileExtMap = /* @__PURE__ */ new Map();
-                    for (const f of jsonFiles)
-                        fileExtMap.set(f, ".json");
-                    for (const f of binFiles)
-                        fileExtMap.set(f, ".bin");
-                    const chunkFiles = [
-                        ...fileExtMap.keys()
-                    ].filter((file2) => file2.startsWith(`${name}-`)).sort();
-                    let isComplete = false;
-                    for (let i = startIndex; i < chunkFiles.length; i++) {
-                        const file2 = chunkFiles[i];
-                        const chunkId = file2.substring(name.length + 1);
-                        if (deliveredChunkIds.has(chunkId)) {
-                            continue;
-                        }
-                        const ext = fileExtMap.get(file2) ?? ".bin";
-                        const chunk = deserializeChunk(await readBuffer(import_node_path8.default.join(chunksDir, `${file2}${ext}`)));
-                        if (chunk?.eof === true) {
-                            isComplete = true;
-                            break;
-                        }
-                        if (chunk.chunk.byteLength) {
-                            controller.enqueue(Uint8Array.from(chunk.chunk));
-                        }
-                    }
-                    isReadingFromDisk = false;
-                    bufferedEventChunks.sort((a, b) => a.chunkId.localeCompare(b.chunkId));
-                    for (const buffered of bufferedEventChunks) {
-                        controller.enqueue(Uint8Array.from(buffered.chunkData));
-                    }
-                    if (isComplete) {
-                        removeListeners();
-                        try {
-                            controller.close();
-                        }
-                        catch {
-                        }
-                        return;
-                    }
-                    if (pendingClose) {
-                        streamEmitter.off(`chunk:${name}`, chunkListener);
-                        streamEmitter.off(`close:${name}`, closeListener);
-                        try {
-                            controller.close();
-                        }
-                        catch {
-                        }
-                    }
-                },
-                cancel() {
-                    removeListeners();
-                }
+            return Response.json({
+                error: "Failed to process queue message"
+            }, {
+                status: 500
             });
         }
     };
 }
-__name(createStreamer, "createStreamer");
-// ../world-local/dist/index.js
-function createLocalWorld(args) {
-    const definedArgs = args ? Object.fromEntries(Object.entries(args).filter(([, value]) => value !== void 0)) : {};
-    const mergedConfig = {
-        ...config2.value,
-        ...definedArgs
-    };
-    return {
-        ...createQueue(mergedConfig),
-        ...createStorage(mergedConfig.dataDir),
-        ...createStreamer(mergedConfig.dataDir),
-        async start() {
-            await initDataDir(mergedConfig.dataDir);
-        }
-    };
-}
-__name(createLocalWorld, "createLocalWorld");
+__name(handleCallback2, "handleCallback2");
 // ../world-vercel/dist/utils.js
 var import_node_os = __toESM(require("node:os"), 1);
 var import_node_util2 = require("node:util");
-var import_oidc2 = __toESM(require_dist(), 1);
+var import_oidc4 = __toESM(require_dist(), 1);
 // ../../node_modules/.pnpm/cbor-x@1.6.0/node_modules/cbor-x/decode.js
 var decoder;
 try {
@@ -47236,7 +48101,7 @@ var RpcSystem3 = SemanticConvention3("rpc.system");
 var RpcService3 = SemanticConvention3("rpc.service");
 var RpcMethod3 = SemanticConvention3("rpc.method");
 // ../world-vercel/dist/version.js
-var version2 = "4.1.0-beta.32";
+var version2 = "4.1.0-beta.34";
 // ../world-vercel/dist/utils.js
 var WORKFLOW_SERVER_URL_OVERRIDE = "";
 var DEFAULT_RESOLVE_DATA_OPTION2 = "all";
@@ -47324,7 +48189,7 @@ async function getHttpConfig(config3) {
     const headers = getHeaders(config3, {
         usingProxy
     });
-    const token = config3?.token ?? await (0, import_oidc2.getVercelOidcToken)();
+    const token = config3?.token ?? await (0, import_oidc4.getVercelOidcToken)();
     if (token) {
         headers.set("Authorization", `Bearer ${token}`);
     }
@@ -47486,12 +48351,26 @@ var MessageWrapper = object({
 var MAX_DELAY_SECONDS = Number(process.env.VERCEL_QUEUE_MAX_DELAY_SECONDS || 82800
 // 23 hours - leave 1h buffer before 24h retention limit
 );
+function getHeadersFromPayload(payload) {
+    const headers = {};
+    if ("runId" in payload && typeof payload.runId === "string") {
+        headers["x-workflow-run-id"] = payload.runId;
+    }
+    if ("workflowRunId" in payload && typeof payload.workflowRunId === "string") {
+        headers["x-workflow-run-id"] = payload.workflowRunId;
+    }
+    if ("stepId" in payload && typeof payload.stepId === "string") {
+        headers["x-workflow-step-id"] = payload.stepId;
+    }
+    return Object.keys(headers).length > 0 ? headers : void 0;
+}
+__name(getHeadersFromPayload, "getHeadersFromPayload");
 function createQueue2(config3) {
     const { baseUrl, usingProxy } = getHttpUrl(config3);
     const headers = getHeaders(config3, {
         usingProxy
     });
-    const baseClientOptions = {
+    const clientOptions = {
         baseUrl: usingProxy ? baseUrl : void 0,
         // The proxy will strip `/queues` from the path, and add `/api` in front,
         // so this ends up being `/api/v3/topic` when arriving at the queue server,
@@ -47505,8 +48384,8 @@ function createQueue2(config3) {
         if (!deploymentId) {
             throw new Error("No deploymentId provided and VERCEL_DEPLOYMENT_ID environment variable is not set. Queue messages require a deployment ID to route correctly. Either set VERCEL_DEPLOYMENT_ID or provide deploymentId in options.");
         }
-        const sendMessageClient = new Client({
-            ...baseClientOptions,
+        const client = new QueueClient({
+            ...clientOptions,
             deploymentId
         });
         const hasEncoder = typeof MessageWrapper.encode === "function";
@@ -47522,10 +48401,15 @@ function createQueue2(config3) {
         });
         const sanitizedQueueName = queueName.replace(/[^A-Za-z0-9-_]/g, "-");
         try {
-            const { messageId } = await sendMessageClient.send(sanitizedQueueName, encoded, {
+            const { messageId } = await client.sendMessage({
+                queueName: sanitizedQueueName,
+                payload: encoded,
                 idempotencyKey: opts?.idempotencyKey,
                 delaySeconds: opts?.delaySeconds,
-                headers: opts?.headers
+                headers: {
+                    ...getHeadersFromPayload(payload),
+                    ...opts?.headers
+                }
             });
             return {
                 messageId: MessageId.parse(messageId)
@@ -47540,30 +48424,26 @@ function createQueue2(config3) {
             throw error45;
         }
     }, "queue");
-    const handleCallbackClient = new Client({
-        ...baseClientOptions
-    });
-    const createQueueHandler = /* @__PURE__ */ __name((prefix, handler) => {
-        return handleCallbackClient.handleCallback({
-            [`${prefix}*`]: {
-                default: /* @__PURE__ */ __name(async (body, meta) => {
-                    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 delaySeconds = Math.min(result.timeoutSeconds, MAX_DELAY_SECONDS);
-                        await queue(queueName, payload, {
-                            deploymentId,
-                            delaySeconds
-                        });
-                        return void 0;
-                    }
-                    return void 0;
-                }, "default")
+    const createQueueHandler = /* @__PURE__ */ __name((_prefix, handler) => {
+        return handleCallback2(async (message, metadata) => {
+            if (!message || !metadata) {
+                return;
             }
+            const { payload, queueName, deploymentId } = MessageWrapper.parse(message);
+            const result = await handler(payload, {
+                queueName,
+                messageId: MessageId.parse(metadata.messageId),
+                attempt: metadata.deliveryCount
+            });
+            if (typeof result?.timeoutSeconds === "number") {
+                const delaySeconds = Math.min(result.timeoutSeconds, MAX_DELAY_SECONDS);
+                await queue(queueName, payload, {
+                    deploymentId,
+                    delaySeconds
+                });
+            }
+        }, {
+            client: new QueueClient(clientOptions)
         });
     }, "createQueueHandler");
     const getDeploymentId = /* @__PURE__ */ __name(async () => {
@@ -48207,10 +49087,12 @@ function createStreamer2(config3) {
 __name(createStreamer2, "createStreamer");
 // ../world-vercel/dist/index.js
 function createVercelWorld(config3) {
+    const projectId = config3?.projectConfig?.projectId || process.env.VERCEL_PROJECT_ID;
     return {
         ...createQueue2(config3),
         ...createStorage2(config3),
-        ...createStreamer2(config3)
+        ...createStreamer2(config3),
+        getEncryptionKeyForRun: createGetEncryptionKeyForRun(projectId, config3?.token)
     };
 }
 __name(createVercelWorld, "createVercelWorld");
@@ -48234,6 +49116,7 @@ var createWorld = /* @__PURE__ */ __name(() => {
             projectConfig: {
                 environment: process.env.WORKFLOW_VERCEL_ENV,
                 projectId: process.env.WORKFLOW_VERCEL_PROJECT,
+                projectName: process.env.WORKFLOW_VERCEL_PROJECT_NAME,
                 teamId: process.env.WORKFLOW_VERCEL_TEAM
             }
         });
@@ -48921,7 +49804,7 @@ function getStepRevivers(global2 = globalThis, ops, runId) {
     };
 }
 __name(getStepRevivers, "getStepRevivers");
-function hydrateStepArguments(value, ops, runId, global2 = globalThis, extraRevivers = {}) {
+async function hydrateStepArguments(value, runId, _key, ops = [], global2 = globalThis, extraRevivers = {}) {
     if (!(value instanceof Uint8Array)) {
         return unflatten(value, {
             ...getStepRevivers(global2, ops, runId),
@@ -48940,7 +49823,7 @@ function hydrateStepArguments(value, ops, runId, global2 = globalThis, extraRevi
     throw new Error(`Unsupported serialization format: ${format}`);
 }
 __name(hydrateStepArguments, "hydrateStepArguments");
-function dehydrateStepReturnValue(value, ops, runId, global2 = globalThis, v1Compat = false) {
+async function dehydrateStepReturnValue(value, runId, _key, ops = [], global2 = globalThis, v1Compat = false) {
     try {
         const str = stringify(value, getStepReducers(global2, ops, runId));
         if (v1Compat) {
@@ -49095,21 +49978,47 @@ async function withServerErrorRetry(fn) {
 }
 __name(withServerErrorRetry, "withServerErrorRetry");
 // ../core/dist/runtime/resume-hook.js
-async function getHookByToken2(token) {
+async function getHookByTokenWithKey(token) {
     const world = getWorld();
     const hook = await world.hooks.getByToken(token);
+    const run = await world.runs.get(hook.runId);
+    const rawKey = await world.getEncryptionKeyForRun?.(run);
+    const encryptionKey = rawKey ? await importKey(rawKey) : void 0;
     if (typeof hook.metadata !== "undefined") {
-        hook.metadata = hydrateStepArguments(hook.metadata, [], hook.runId);
+        hook.metadata = await hydrateStepArguments(hook.metadata, hook.runId, encryptionKey);
     }
-    return hook;
+    return {
+        hook,
+        run,
+        encryptionKey
+    };
 }
-__name(getHookByToken2, "getHookByToken");
-async function resumeHook(tokenOrHook, payload) {
+__name(getHookByTokenWithKey, "getHookByTokenWithKey");
+async function resumeHook(tokenOrHook, payload, encryptionKeyOverride) {
     return await waitedUntil(() => {
         return trace("hook.resume", async (span) => {
             const world = getWorld();
             try {
-                const hook = typeof tokenOrHook === "string" ? await getHookByToken2(tokenOrHook) : tokenOrHook;
+                let hook;
+                let workflowRun;
+                let encryptionKey;
+                if (typeof tokenOrHook === "string") {
+                    const result = await getHookByTokenWithKey(tokenOrHook);
+                    hook = result.hook;
+                    workflowRun = result.run;
+                    encryptionKey = encryptionKeyOverride ?? result.encryptionKey;
+                }
+                else {
+                    hook = tokenOrHook;
+                    workflowRun = await world.runs.get(hook.runId);
+                    if (encryptionKeyOverride) {
+                        encryptionKey = encryptionKeyOverride;
+                    }
+                    else {
+                        const rawKey = await world.getEncryptionKeyForRun?.(workflowRun);
+                        encryptionKey = rawKey ? await importKey(rawKey) : void 0;
+                    }
+                }
                 span?.setAttributes({
                     ...HookToken(hook.token),
                     ...HookId(hook.hookId),
@@ -49117,7 +50026,7 @@ async function resumeHook(tokenOrHook, payload) {
                 });
                 const ops = [];
                 const v1Compat = isLegacySpecVersion(hook.specVersion);
-                const dehydratedPayload = dehydrateStepReturnValue(payload, ops, hook.runId, globalThis, v1Compat);
+                const dehydratedPayload = await dehydrateStepReturnValue(payload, hook.runId, encryptionKey, ops, globalThis, v1Compat);
                 (0, import_functions2.waitUntil)(Promise.all(ops).catch((err) => {
                     if (err !== void 0)
                         throw err;
@@ -49132,7 +50041,6 @@ async function resumeHook(tokenOrHook, payload) {
                 }, {
                     v1Compat
                 });
-                const workflowRun = await world.runs.get(hook.runId);
                 span?.setAttributes({
                     ...WorkflowName(workflowRun.workflowName)
                 });
@@ -49442,7 +50350,7 @@ var stepHandler = getWorldHandlers().createQueueHandler("__wkf_step_", async (me
                         };
                     }
                     if (err.status === 410) {
-                        console.warn(`Workflow run "${workflowRunId}" has already completed, skipping step "${stepId}": ${err.message}`);
+                        runtimeLogger.info(`Workflow run "${workflowRunId}" has already completed, skipping step "${stepId}": ${err.message}`);
                         return;
                     }
                     if (err.status === 409) {
@@ -49512,15 +50420,29 @@ var stepHandler = getWorldHandlers().createQueueHandler("__wkf_step_", async (me
                     stepName,
                     retryCount
                 });
-                await world.events.create(workflowRunId, {
-                    eventType: "step_failed",
-                    specVersion: SPEC_VERSION_CURRENT,
-                    correlationId: stepId,
-                    eventData: {
-                        error: errorMessage,
-                        stack: step.error?.stack
+                try {
+                    await world.events.create(workflowRunId, {
+                        eventType: "step_failed",
+                        specVersion: SPEC_VERSION_CURRENT,
+                        correlationId: stepId,
+                        eventData: {
+                            error: errorMessage,
+                            stack: step.error?.stack
+                        }
+                    });
+                }
+                catch (err) {
+                    if (WorkflowAPIError.is(err) && err.status === 409) {
+                        runtimeLogger.warn("Tried failing step, but step has already finished.", {
+                            workflowRunId,
+                            stepId,
+                            stepName,
+                            message: err.message
+                        });
+                        return;
                     }
-                });
+                    throw err;
+                }
                 span?.setAttributes({
                     ...StepStatus("failed"),
                     ...StepRetryExhausted(true)
@@ -49529,10 +50451,6 @@ var stepHandler = getWorldHandlers().createQueueHandler("__wkf_step_", async (me
                     runId: workflowRunId,
                     traceCarrier: await serializeTraceCarrier(),
                     requestedAt: /* @__PURE__ */ new Date()
-                }, {
-                    headers: {
-                        "x-workflow-run-id": workflowRunId
-                    }
                 });
                 return;
             }
@@ -49543,9 +50461,11 @@ var stepHandler = getWorldHandlers().createQueueHandler("__wkf_step_", async (me
                 }
                 const stepStartedAt = step.startedAt;
                 const ops = [];
+                const rawKey = await world.getEncryptionKeyForRun?.(workflowRunId);
+                const encryptionKey = rawKey ? await importKey(rawKey) : void 0;
                 const hydratedInput = await trace("step.hydrate", {}, async (hydrateSpan) => {
                     const startTime = Date.now();
-                    const result2 = hydrateStepArguments(step.input, ops, workflowRunId);
+                    const result2 = await hydrateStepArguments(step.input, workflowRunId, encryptionKey, ops);
                     const durationMs = Date.now() - startTime;
                     hydrateSpan?.setAttributes({
                         ...StepArgumentsCount(result2.args.length),
@@ -49580,7 +50500,7 @@ var stepHandler = getWorldHandlers().createQueueHandler("__wkf_step_", async (me
                 });
                 result = await trace("step.dehydrate", {}, async (dehydrateSpan) => {
                     const startTime = Date.now();
-                    const dehydrated = dehydrateStepReturnValue(result, ops, workflowRunId);
+                    const dehydrated = await dehydrateStepReturnValue(result, workflowRunId, encryptionKey, ops);
                     const durationMs = Date.now() - startTime;
                     dehydrateSpan?.setAttributes({
                         ...QueueSerializeTimeMs(durationMs),
@@ -49593,6 +50513,7 @@ var stepHandler = getWorldHandlers().createQueueHandler("__wkf_step_", async (me
                     if (!isAbortError)
                         throw err;
                 }));
+                let stepCompleted409 = false;
                 const [, traceCarrier] = await Promise.all([
                     withServerErrorRetry(() => world.events.create(workflowRunId, {
                         eventType: "step_completed",
@@ -49601,9 +50522,24 @@ var stepHandler = getWorldHandlers().createQueueHandler("__wkf_step_", async (me
                         eventData: {
                             result
                         }
-                    })),
+                    })).catch((err) => {
+                        if (WorkflowAPIError.is(err) && err.status === 409) {
+                            runtimeLogger.warn("Tried completing step, but step has already finished.", {
+                                workflowRunId,
+                                stepId,
+                                stepName,
+                                message: err.message
+                            });
+                            stepCompleted409 = true;
+                            return;
+                        }
+                        throw err;
+                    }),
                     serializeTraceCarrier()
                 ]);
+                if (stepCompleted409) {
+                    return;
+                }
                 span?.setAttributes({
                     ...StepStatus("completed"),
                     ...StepResultType(typeof result)
@@ -49657,15 +50593,29 @@ var stepHandler = getWorldHandlers().createQueueHandler("__wkf_step_", async (me
                         stepName,
                         errorStack: normalizedStack
                     });
-                    await withServerErrorRetry(() => world.events.create(workflowRunId, {
-                        eventType: "step_failed",
-                        specVersion: SPEC_VERSION_CURRENT,
-                        correlationId: stepId,
-                        eventData: {
-                            error: normalizedError.message,
-                            stack: normalizedStack
+                    try {
+                        await withServerErrorRetry(() => world.events.create(workflowRunId, {
+                            eventType: "step_failed",
+                            specVersion: SPEC_VERSION_CURRENT,
+                            correlationId: stepId,
+                            eventData: {
+                                error: normalizedError.message,
+                                stack: normalizedStack
+                            }
+                        }));
+                    }
+                    catch (stepFailErr) {
+                        if (WorkflowAPIError.is(stepFailErr) && stepFailErr.status === 409) {
+                            runtimeLogger.warn("Tried failing step, but step has already finished.", {
+                                workflowRunId,
+                                stepId,
+                                stepName,
+                                message: stepFailErr.message
+                            });
+                            return;
                         }
-                    }));
+                        throw stepFailErr;
+                    }
                     span?.setAttributes({
                         ...StepStatus("failed"),
                         ...StepFatalError(true)
@@ -49688,15 +50638,29 @@ var stepHandler = getWorldHandlers().createQueueHandler("__wkf_step_", async (me
                             errorStack: normalizedStack
                         });
                         const errorMessage = `Step "${stepName}" failed after ${maxRetries2} ${pluralize("retry", "retries", maxRetries2)}: ${normalizedError.message}`;
-                        await withServerErrorRetry(() => world.events.create(workflowRunId, {
-                            eventType: "step_failed",
-                            specVersion: SPEC_VERSION_CURRENT,
-                            correlationId: stepId,
-                            eventData: {
-                                error: errorMessage,
-                                stack: normalizedStack
+                        try {
+                            await withServerErrorRetry(() => world.events.create(workflowRunId, {
+                                eventType: "step_failed",
+                                specVersion: SPEC_VERSION_CURRENT,
+                                correlationId: stepId,
+                                eventData: {
+                                    error: errorMessage,
+                                    stack: normalizedStack
+                                }
+                            }));
+                        }
+                        catch (stepFailErr) {
+                            if (WorkflowAPIError.is(stepFailErr) && stepFailErr.status === 409) {
+                                runtimeLogger.warn("Tried failing step, but step has already finished.", {
+                                    workflowRunId,
+                                    stepId,
+                                    stepName,
+                                    message: stepFailErr.message
+                                });
+                                return;
                             }
-                        }));
+                            throw stepFailErr;
+                        }
                         span?.setAttributes({
                             ...StepStatus("failed"),
                             ...StepRetryExhausted(true)
@@ -49719,18 +50683,32 @@ var stepHandler = getWorldHandlers().createQueueHandler("__wkf_step_", async (me
                                 errorStack: normalizedStack
                             });
                         }
-                        await withServerErrorRetry(() => world.events.create(workflowRunId, {
-                            eventType: "step_retrying",
-                            specVersion: SPEC_VERSION_CURRENT,
-                            correlationId: stepId,
-                            eventData: {
-                                error: normalizedError.message,
-                                stack: normalizedStack,
-                                ...RetryableError.is(err) && {
-                                    retryAfter: err.retryAfter
+                        try {
+                            await withServerErrorRetry(() => world.events.create(workflowRunId, {
+                                eventType: "step_retrying",
+                                specVersion: SPEC_VERSION_CURRENT,
+                                correlationId: stepId,
+                                eventData: {
+                                    error: normalizedError.message,
+                                    stack: normalizedStack,
+                                    ...RetryableError.is(err) && {
+                                        retryAfter: err.retryAfter
+                                    }
                                 }
+                            }));
+                        }
+                        catch (stepRetryErr) {
+                            if (WorkflowAPIError.is(stepRetryErr) && stepRetryErr.status === 409) {
+                                runtimeLogger.warn("Tried retrying step, but step has already finished.", {
+                                    workflowRunId,
+                                    stepId,
+                                    stepName,
+                                    message: stepRetryErr.message
+                                });
+                                return;
                             }
-                        }));
+                            throw stepRetryErr;
+                        }
                         const timeoutSeconds = Math.max(1, RetryableError.is(err) ? Math.ceil((+err.retryAfter.getTime() - Date.now()) / 1e3) : 1);
                         span?.setAttributes({
                             ...StepRetryTimeoutSeconds(timeoutSeconds),
@@ -49751,10 +50729,6 @@ var stepHandler = getWorldHandlers().createQueueHandler("__wkf_step_", async (me
                 runId: workflowRunId,
                 traceCarrier: await serializeTraceCarrier(),
                 requestedAt: /* @__PURE__ */ new Date()
-            }, {
-                headers: {
-                    "x-workflow-run-id": workflowRunId
-                }
             });
         });
     });