@workflow/world-testing 4.0.1-beta.5 → 4.0.1-beta.7

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

@@ -1156,43 +1156,43 @@ var require_ms = __commonJS({
             }
         }
         __name(parse4, "parse");
-        function fmtShort(ms2) {
-            var msAbs = Math.abs(ms2);
+        function fmtShort(ms3) {
+            var msAbs = Math.abs(ms3);
             if (msAbs >= d) {
-                return Math.round(ms2 / d) + "d";
+                return Math.round(ms3 / d) + "d";
             }
             if (msAbs >= h) {
-                return Math.round(ms2 / h) + "h";
+                return Math.round(ms3 / h) + "h";
             }
             if (msAbs >= m) {
-                return Math.round(ms2 / m) + "m";
+                return Math.round(ms3 / m) + "m";
             }
             if (msAbs >= s) {
-                return Math.round(ms2 / s) + "s";
+                return Math.round(ms3 / s) + "s";
             }
-            return ms2 + "ms";
+            return ms3 + "ms";
         }
         __name(fmtShort, "fmtShort");
-        function fmtLong(ms2) {
-            var msAbs = Math.abs(ms2);
+        function fmtLong(ms3) {
+            var msAbs = Math.abs(ms3);
             if (msAbs >= d) {
-                return plural(ms2, msAbs, d, "day");
+                return plural(ms3, msAbs, d, "day");
             }
             if (msAbs >= h) {
-                return plural(ms2, msAbs, h, "hour");
+                return plural(ms3, msAbs, h, "hour");
             }
             if (msAbs >= m) {
-                return plural(ms2, msAbs, m, "minute");
+                return plural(ms3, msAbs, m, "minute");
             }
             if (msAbs >= s) {
-                return plural(ms2, msAbs, s, "second");
+                return plural(ms3, msAbs, s, "second");
             }
-            return ms2 + " ms";
+            return ms3 + " ms";
         }
         __name(fmtLong, "fmtLong");
-        function plural(ms2, msAbs, n, name) {
+        function plural(ms3, msAbs, n, name) {
             var isPlural = msAbs >= n * 1.5;
-            return Math.round(ms2 / n) + " " + name + (isPlural ? "s" : "");
+            return Math.round(ms3 / n) + " " + name + (isPlural ? "s" : "");
         }
         __name(plural, "plural");
     }
@@ -1236,8 +1236,8 @@ var require_common = __commonJS({
                     }
                     const self2 = debug2;
                     const curr = Number(/* @__PURE__ */ new Date());
-                    const ms2 = curr - (prevTime || curr);
-                    self2.diff = ms2;
+                    const ms3 = curr - (prevTime || curr);
+                    self2.diff = ms3;
                     self2.prev = prevTime;
                     self2.curr = curr;
                     prevTime = curr;
@@ -4815,6 +4815,10 @@ var import_functions3 = __toESM(require_functions(), 1);
 // ../errors/dist/index.js
 var import_ms = __toESM(require_ms(), 1);
 var BASE_URL = "https://useworkflow.dev/err";
+function isError(value) {
+    return typeof value === "object" && value !== null && "name" in value && "message" in value;
+}
+__name(isError, "isError");
 var ERROR_SLUGS = {
     NODE_JS_MODULE_IN_WORKFLOW: "node-js-module-in-workflow",
     START_INVALID_WORKFLOW_FUNCTION: "start-invalid-workflow-function",
@@ -4839,6 +4843,9 @@ Learn more: ${BASE_URL}/${options.slug}` : message;
 Caused by: ${options.cause.stack}`;
         }
     }
+    static is(value) {
+        return isError(value) && value.name === "WorkflowError";
+    }
 };
 var WorkflowAPIError = class extends WorkflowError {
     static {
@@ -4856,6 +4863,9 @@ var WorkflowAPIError = class extends WorkflowError {
         this.code = options?.code;
         this.url = options?.url;
     }
+    static is(value) {
+        return isError(value) && value.name === "WorkflowAPIError";
+    }
 };
 var WorkflowRuntimeError = class extends WorkflowError {
     static {
@@ -4867,6 +4877,9 @@ var WorkflowRuntimeError = class extends WorkflowError {
         });
         this.name = "WorkflowRuntimeError";
     }
+    static is(value) {
+        return isError(value) && value.name === "WorkflowRuntimeError";
+    }
 };
 var WorkflowRunNotFoundError = class extends WorkflowError {
     static {
@@ -4878,6 +4891,9 @@ var WorkflowRunNotFoundError = class extends WorkflowError {
         this.name = "WorkflowRunNotFoundError";
         this.runId = runId;
     }
+    static is(value) {
+        return isError(value) && value.name === "WorkflowRunNotFoundError";
+    }
 };
 var FatalError = class extends Error {
     static {
@@ -4888,9 +4904,12 @@ var FatalError = class extends Error {
         super(message);
         this.name = "FatalError";
     }
+    static is(value) {
+        return isError(value) && value.name === "FatalError";
+    }
 };
 // ../core/dist/global.js
-var WorkflowSuspension = class extends Error {
+var WorkflowSuspension = class _WorkflowSuspension extends Error {
     static {
         __name(this, "WorkflowSuspension");
     }
@@ -4898,9 +4917,11 @@ var WorkflowSuspension = class extends Error {
     globalThis;
     stepCount;
     hookCount;
+    waitCount;
     constructor(steps, global2) {
         const stepCount = steps.filter((s) => s.type === "step").length;
         const hookCount = steps.filter((s) => s.type === "hook").length;
+        const waitCount = steps.filter((s) => s.type === "wait").length;
         const parts = [];
         if (stepCount > 0) {
             parts.push(`${stepCount} ${stepCount === 1 ? "step" : "steps"}`);
@@ -4908,7 +4929,10 @@ var WorkflowSuspension = class extends Error {
         if (hookCount > 0) {
             parts.push(`${hookCount} ${hookCount === 1 ? "hook" : "hooks"}`);
         }
-        const totalCount = stepCount + hookCount;
+        if (waitCount > 0) {
+            parts.push(`${waitCount} ${waitCount === 1 ? "wait" : "waits"}`);
+        }
+        const totalCount = stepCount + hookCount + waitCount;
         const hasOrHave = totalCount === 1 ? "has" : "have";
         let action;
         if (stepCount > 0) {
@@ -4917,6 +4941,9 @@ var WorkflowSuspension = class extends Error {
         else if (hookCount > 0) {
             action = "created";
         }
+        else if (waitCount > 0) {
+            action = "created";
+        }
         else {
             action = "received";
         }
@@ -4927,6 +4954,10 @@ var WorkflowSuspension = class extends Error {
         this.globalThis = global2;
         this.stepCount = stepCount;
         this.hookCount = hookCount;
+        this.waitCount = waitCount;
+    }
+    static is(value) {
+        return value instanceof _WorkflowSuspension;
     }
 };
 function ENOTSUP() {
@@ -4957,8 +4988,8 @@ function once(fn) {
     return result;
 }
 __name(once, "once");
-function buildWorkflowSuspensionMessage(runId, stepCount, hookCount) {
-    if (stepCount === 0 && hookCount === 0) {
+function buildWorkflowSuspensionMessage(runId, stepCount, hookCount, waitCount) {
+    if (stepCount === 0 && hookCount === 0 && waitCount === 0) {
         return null;
     }
     const parts = [];
@@ -4968,7 +4999,20 @@ function buildWorkflowSuspensionMessage(runId, stepCount, hookCount) {
     if (hookCount > 0) {
         parts.push(`${hookCount} ${hookCount === 1 ? "hook" : "hooks"}`);
     }
-    const resumeMsg = hookCount > 0 ? "steps are created and hooks are triggered" : "steps are created";
+    if (waitCount > 0) {
+        parts.push(`${waitCount} ${waitCount === 1 ? "timer" : "timers"}`);
+    }
+    const resumeMsgParts = [];
+    if (stepCount > 0) {
+        resumeMsgParts.push("steps are completed");
+    }
+    if (hookCount > 0) {
+        resumeMsgParts.push("hooks are received");
+    }
+    if (waitCount > 0) {
+        resumeMsgParts.push("timers have elapsed");
+    }
+    const resumeMsg = resumeMsgParts.join(" and ");
     return `[Workflows] "${runId}" - ${parts.join(" and ")} to be enqueued
   Workflow will suspend and resume when ${resumeMsg}`;
 }
@@ -5124,503 +5168,50 @@ var config = once2(() => {
 });
 // ../world-local/dist/queue.js
 var import_promises = require("node:timers/promises");
-// ../../node_modules/.pnpm/mixpart@0.0.5-alpha.0/node_modules/mixpart/dist/index.mjs
-var MultipartParseError = class extends Error {
-    static {
-        __name(this, "MultipartParseError");
-    }
-    constructor(message) {
-        super(message);
-        this.name = "MultipartParseError";
-    }
-};
-function createSearch(pattern) {
-    const needle = new TextEncoder().encode(pattern);
-    return (haystack, start2 = 0) => Buffer.prototype.indexOf.call(haystack, needle, start2);
-}
-__name(createSearch, "createSearch");
-function createPartialTailSearch(pattern) {
-    const needle = new TextEncoder().encode(pattern);
-    const byteIndexes = {};
-    for (let i = 0; i < needle.length; ++i) {
-        const byte = needle[i];
-        if (byteIndexes[byte] === void 0)
-            byteIndexes[byte] = [];
-        byteIndexes[byte].push(i);
-    }
-    return function (haystack) {
-        const haystackEnd = haystack.length - 1;
-        if (haystack[haystackEnd] in byteIndexes) {
-            const indexes = byteIndexes[haystack[haystackEnd]];
-            for (let i = indexes.length - 1; i >= 0; --i) {
-                for (let j = indexes[i], k = haystackEnd; j >= 0 && haystack[k] === needle[j]; --j, --k) {
-                    if (j === 0)
-                        return k;
-                }
-            }
-        }
-        return -1;
-    };
-}
-__name(createPartialTailSearch, "createPartialTailSearch");
-function parseHeaders(headerBytes) {
-    const headerText = new TextDecoder("iso-8859-1").decode(headerBytes);
-    const lines = headerText.trim().split(/\r?\n/);
-    const headerInit = [];
-    for (const line of lines) {
-        const colonIndex = line.indexOf(":");
-        if (colonIndex > 0) {
-            const name = line.slice(0, colonIndex).trim();
-            const value = line.slice(colonIndex + 1).trim();
-            headerInit.push([name, value]);
+// ../../node_modules/.pnpm/@vercel+queue@0.0.0-alpha.23/node_modules/@vercel/queue/dist/index.mjs
+async function streamToBuffer(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;
         }
     }
-    return new Headers(headerInit);
-}
-__name(parseHeaders, "parseHeaders");
-function extractBoundary(contentType) {
-    const boundaryMatch = contentType.match(/boundary=(?:"([^"]+)"|([^;]+))/i);
-    if (!boundaryMatch) {
-        throw new MultipartParseError("No boundary found in Content-Type header");
+    finally {
+        reader.releaseLock();
     }
-    return boundaryMatch[1] ?? boundaryMatch[2];
+    return Buffer.concat(chunks, totalLength);
 }
-__name(extractBoundary, "extractBoundary");
-var AsyncMessageQueue = class {
+__name(streamToBuffer, "streamToBuffer");
+var JsonTransport = class {
     static {
-        __name(this, "AsyncMessageQueue");
-    }
-    queue = [];
-    waiters = [];
-    finished = false;
-    cancelled = false;
-    error = null;
-    /**
-     * Producer: Enqueue a message for consumption
-     */
-    enqueue(message) {
-        if (this.finished || this.cancelled)
-            return;
-        if (this.waiters.length > 0) {
-            const waiter = this.waiters.shift();
-            waiter.resolve(message);
-        }
-        else {
-            this.queue.push(message);
-        }
-    }
-    /**
-     * Producer: Signal completion (with optional error)
-     */
-    finish(error45) {
-        if (this.finished)
-            return;
-        this.finished = true;
-        this.error = error45 || null;
-        while (this.waiters.length > 0) {
-            const waiter = this.waiters.shift();
-            if (error45) {
-                waiter.reject(error45);
-            }
-            else {
-                waiter.resolve(null);
-            }
-        }
+        __name(this, "JsonTransport");
     }
-    /**
-     * Consumer: Cancel the queue (stops accepting new messages and notifies waiters)
-     */
-    cancel() {
-        if (this.cancelled || this.finished)
-            return;
-        this.cancelled = true;
-        while (this.waiters.length > 0) {
-            const waiter = this.waiters.shift();
-            waiter.resolve(null);
-        }
+    contentType = "application/json";
+    replacer;
+    reviver;
+    constructor(options = {}) {
+        this.replacer = options.replacer;
+        this.reviver = options.reviver;
     }
-    /**
-     * Consumer: Dequeue next message (or null if finished/cancelled)
-     */
-    async dequeue() {
-        if (this.queue.length > 0) {
-            return this.queue.shift();
-        }
-        if (this.finished || this.cancelled) {
-            if (this.error)
-                throw this.error;
-            return null;
-        }
-        return new Promise((resolve, reject) => {
-            this.waiters.push({ resolve, reject });
-        });
+    serialize(value) {
+        return Buffer.from(JSON.stringify(value, this.replacer), "utf8");
     }
-    /**
-     * Check if the queue is in a terminal state
-     */
-    get isTerminal() {
-        return this.finished || this.cancelled;
+    async deserialize(stream) {
+        const buffer = await streamToBuffer(stream);
+        return JSON.parse(buffer.toString("utf8"), this.reviver);
     }
 };
-async function* parseMultipartStream(response, options) {
-    if (!response.body) {
-        throw new MultipartParseError("Response body is null");
-    }
-    const contentType = response.headers.get("content-type");
-    if (!contentType) {
-        throw new MultipartParseError("Missing Content-Type header");
-    }
-    const boundary = extractBoundary(contentType);
-    const parser = new StreamingMultipartParser(boundary, options);
-    yield* parser.parseStream(response.body);
-}
-__name(parseMultipartStream, "parseMultipartStream");
-var StreamingMultipartParser = class {
-    static {
-        __name(this, "StreamingMultipartParser");
-    }
-    boundary;
-    findOpeningBoundary;
-    openingBoundaryLength;
-    findBoundary;
-    findPartialTailBoundary;
-    boundaryLength;
-    findDoubleNewline;
-    // Safety limits
-    maxHeaderSize;
-    maxBoundaryBuffer;
-    state = 0;
-    buffer = null;
-    currentHeaders = new Headers();
-    currentPayloadController = null;
-    constructor(boundary, options = {}) {
-        this.boundary = boundary;
-        this.findOpeningBoundary = createSearch(`--${boundary}`);
-        this.openingBoundaryLength = 2 + boundary.length;
-        this.findBoundary = createSearch(`\r
---${boundary}`);
-        this.findPartialTailBoundary = createPartialTailSearch(`\r
---${boundary}`);
-        this.boundaryLength = 4 + boundary.length;
-        this.findDoubleNewline = createSearch("\r\n\r\n");
-        this.maxHeaderSize = options.maxHeaderSize ?? 65536;
-        this.maxBoundaryBuffer = options.maxBoundaryBuffer ?? 8192;
-    }
-    async *parseStream(stream) {
-        const reader = stream.getReader();
-        const messageQueue = new AsyncMessageQueue();
-        const producer = this.startProducer(reader, messageQueue);
-        try {
-            yield* this.consumeMessages(messageQueue);
-        }
-        finally {
-            messageQueue.cancel();
-            this.closeCurrentPayload();
-            try {
-                await reader.cancel();
-            }
-            catch (error45) {
-            }
-            await producer;
-        }
-    }
-    /**
-     * Producer: Continuously read chunks and parse messages
-     */
-    async startProducer(reader, messageQueue) {
-        try {
-            while (!messageQueue.isTerminal) {
-                let result;
-                try {
-                    result = await reader.read();
-                }
-                catch (readError) {
-                    if (readError instanceof Error && (readError.name === "AbortError" || readError.constructor.name === "AbortError" || readError.name === "TimeoutError" || readError.constructor.name === "TimeoutError")) {
-                        break;
-                    }
-                    throw readError;
-                }
-                const { done, value } = result;
-                if (done) {
-                    if (this.buffer !== null && this.buffer.length > 0) {
-                        const messages2 = this.write(new Uint8Array(0));
-                        for (const message of messages2) {
-                            if (messageQueue.isTerminal)
-                                break;
-                            messageQueue.enqueue(message);
-                        }
-                    }
-                    if (this.state !== 4) {
-                        if (this.state === 0) {
-                            throw new MultipartParseError("Invalid multipart stream: missing initial boundary");
-                        }
-                        throw new MultipartParseError("Unexpected end of stream");
-                    }
-                    break;
-                }
-                if (!(value instanceof Uint8Array)) {
-                    throw new MultipartParseError(`Invalid chunk type: expected Uint8Array, got ${typeof value}`);
-                }
-                const messages = this.write(value);
-                for (const message of messages) {
-                    if (messageQueue.isTerminal)
-                        break;
-                    messageQueue.enqueue(message);
-                }
-            }
-            if (!messageQueue.isTerminal) {
-                messageQueue.finish();
-            }
-        }
-        catch (error45) {
-            this.closeCurrentPayload(error45);
-            if (!messageQueue.isTerminal) {
-                messageQueue.finish(error45);
-            }
-        }
-        finally {
-            try {
-                reader.releaseLock();
-            }
-            catch (error45) {
-            }
-        }
-    }
-    /**
-     * Consumer: Yield messages from the queue
-     */
-    async *consumeMessages(messageQueue) {
-        while (true) {
-            const message = await messageQueue.dequeue();
-            if (message === null) {
-                break;
-            }
-            yield message;
-        }
-    }
-    /**
-     * Process a chunk of data through the state machine and return any complete messages.
-     *
-     * Returns an array because a single chunk can contain multiple complete messages
-     * when small messages with headers + body + boundary all fit in one network chunk.
-     * All messages must be captured and queued to maintain proper message ordering.
-     */
-    write(chunk) {
-        const newMessages = [];
-        if (this.state === 4) {
-            throw new MultipartParseError("Unexpected data after end of stream");
-        }
-        let index = 0;
-        let chunkLength = chunk.length;
-        if (this.buffer !== null) {
-            const newSize = this.buffer.length + chunkLength;
-            const maxAllowedSize = this.state === 2 ? this.maxHeaderSize : this.maxBoundaryBuffer;
-            if (newSize > maxAllowedSize) {
-                throw new MultipartParseError(`Buffer size limit exceeded: ${newSize} bytes > ${maxAllowedSize} bytes. This may indicate malformed multipart data with ${this.state === 2 ? "oversized headers" : "invalid boundaries"}.`);
-            }
-            const newChunk = new Uint8Array(newSize);
-            newChunk.set(this.buffer, 0);
-            newChunk.set(chunk, this.buffer.length);
-            chunk = newChunk;
-            chunkLength = chunk.length;
-            this.buffer = null;
-        }
-        if (chunkLength === 0 && this.state === 0) {
-            throw new MultipartParseError("Invalid multipart stream: missing initial boundary");
-        }
-        while (true) {
-            if (this.state === 3) {
-                if (chunkLength - index < this.boundaryLength) {
-                    const remainingData = chunk.subarray(index);
-                    if (remainingData.length > this.maxBoundaryBuffer) {
-                        throw new MultipartParseError(`Boundary buffer limit exceeded: ${remainingData.length} > ${this.maxBoundaryBuffer}`);
-                    }
-                    this.buffer = remainingData;
-                    break;
-                }
-                const boundaryIndex = this.findBoundary(chunk, index);
-                if (boundaryIndex === -1) {
-                    const partialTailIndex = this.findPartialTailBoundary(chunk);
-                    if (partialTailIndex === -1) {
-                        this.writeBody(index === 0 ? chunk : chunk.subarray(index));
-                    }
-                    else {
-                        this.writeBody(chunk.subarray(index, partialTailIndex));
-                        const partialBoundary = chunk.subarray(partialTailIndex);
-                        if (partialBoundary.length > this.maxBoundaryBuffer) {
-                            throw new MultipartParseError(`Partial boundary too large: ${partialBoundary.length} > ${this.maxBoundaryBuffer}`);
-                        }
-                        this.buffer = partialBoundary;
-                    }
-                    break;
-                }
-                this.writeBody(chunk.subarray(index, boundaryIndex));
-                this.finishMessage();
-                index = boundaryIndex + this.boundaryLength;
-                this.state = 1;
-            }
-            if (this.state === 1) {
-                if (chunkLength - index < 2) {
-                    const remainingData = chunk.subarray(index);
-                    if (remainingData.length > this.maxBoundaryBuffer) {
-                        throw new MultipartParseError(`After-boundary buffer limit exceeded: ${remainingData.length} > ${this.maxBoundaryBuffer}`);
-                    }
-                    this.buffer = remainingData;
-                    break;
-                }
-                if (chunk[index] === 45 && chunk[index + 1] === 45) {
-                    this.state = 4;
-                    break;
-                }
-                if (chunk[index] === 13 && chunk[index + 1] === 10) {
-                    index += 2;
-                }
-                else if (chunk[index] === 10) {
-                    index += 1;
-                }
-                else {
-                    throw new MultipartParseError(`Invalid character after boundary: expected CRLF or LF, got 0x${chunk[index].toString(16)}`);
-                }
-                this.state = 2;
-            }
-            if (this.state === 2) {
-                if (chunkLength - index < 4) {
-                    const remainingData = chunk.subarray(index);
-                    if (remainingData.length > this.maxHeaderSize) {
-                        throw new MultipartParseError(`Header buffer limit exceeded: ${remainingData.length} > ${this.maxHeaderSize}`);
-                    }
-                    this.buffer = remainingData;
-                    break;
-                }
-                let headerEndIndex = this.findDoubleNewline(chunk, index);
-                let headerEndOffset = 4;
-                if (headerEndIndex === -1) {
-                    const lfDoubleNewline = createSearch("\n\n");
-                    headerEndIndex = lfDoubleNewline(chunk, index);
-                    headerEndOffset = 2;
-                }
-                if (headerEndIndex === -1) {
-                    const headerData = chunk.subarray(index);
-                    if (headerData.length > this.maxHeaderSize) {
-                        throw new MultipartParseError(`Headers too large: ${headerData.length} > ${this.maxHeaderSize} bytes`);
-                    }
-                    this.buffer = headerData;
-                    break;
-                }
-                const headerBytes = chunk.subarray(index, headerEndIndex);
-                this.currentHeaders = parseHeaders(headerBytes);
-                const message = this.createStreamingMessage();
-                newMessages.push(message);
-                index = headerEndIndex + headerEndOffset;
-                this.state = 3;
-                continue;
-            }
-            if (this.state === 0) {
-                if (chunkLength < this.openingBoundaryLength) {
-                    if (chunk.length > this.maxBoundaryBuffer) {
-                        throw new MultipartParseError(`Initial chunk too large for boundary detection: ${chunk.length} > ${this.maxBoundaryBuffer}`);
-                    }
-                    this.buffer = chunk;
-                    break;
-                }
-                const boundaryIndex = this.findOpeningBoundary(chunk);
-                if (boundaryIndex !== 0) {
-                    throw new MultipartParseError("Invalid multipart stream: missing initial boundary");
-                }
-                index = this.openingBoundaryLength;
-                this.state = 1;
-            }
-        }
-        return newMessages;
-    }
-    createStreamingMessage() {
-        const headers = new Headers(this.currentHeaders);
-        const payload = new ReadableStream({
-            start: /* @__PURE__ */ __name((controller) => {
-                this.currentPayloadController = controller;
-            }, "start")
-        });
-        this.currentHeaders = new Headers();
-        return {
-            headers,
-            payload
-        };
-    }
-    writeBody(chunk) {
-        if (this.currentPayloadController) {
-            this.currentPayloadController.enqueue(chunk);
-        }
-    }
-    finishMessage() {
-        if (this.currentPayloadController) {
-            this.currentPayloadController.close();
-            this.currentPayloadController = null;
-        }
-    }
-    /**
-     * Close current payload controller if open (used during cleanup)
-     * If an error is provided, forwards it to the payload consumer
-     */
-    closeCurrentPayload(error45) {
-        if (this.currentPayloadController) {
-            try {
-                if (error45) {
-                    this.currentPayloadController.error(error45);
-                }
-                else {
-                    this.currentPayloadController.close();
-                }
-            }
-            catch (controllerError) {
-            }
-            this.currentPayloadController = null;
-        }
-    }
-};
-// ../../node_modules/.pnpm/@vercel+queue@0.0.0-alpha.23/node_modules/@vercel/queue/dist/index.mjs
-async function streamToBuffer(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(streamToBuffer, "streamToBuffer");
-var JsonTransport = class {
-    static {
-        __name(this, "JsonTransport");
-    }
-    contentType = "application/json";
-    replacer;
-    reviver;
-    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 streamToBuffer(stream);
-        return JSON.parse(buffer.toString("utf8"), this.reviver);
-    }
-};
-var devRouteHandlers = /* @__PURE__ */ new Map();
-var wildcardRouteHandlers = /* @__PURE__ */ new Map();
-function clearDevHandlers() {
-    devRouteHandlers.clear();
-    wildcardRouteHandlers.clear();
+var devRouteHandlers = /* @__PURE__ */ new Map();
+var wildcardRouteHandlers = /* @__PURE__ */ new Map();
+function clearDevHandlers() {
+    devRouteHandlers.clear();
+    wildcardRouteHandlers.clear();
 }
 __name(clearDevHandlers, "clearDevHandlers");
 if (process.env.NODE_ENV === "test" || process.env.VITEST) {
@@ -18486,6 +18077,8 @@ var EventTypeSchema = external_exports.enum([
     "hook_created",
     "hook_received",
     "hook_disposed",
+    "wait_created",
+    "wait_completed",
     "workflow_completed",
     "workflow_failed",
     "workflow_started"
@@ -18537,6 +18130,17 @@ var HookDisposedEventSchema = BaseEventSchema.extend({
     eventType: external_exports.literal("hook_disposed"),
     correlationId: external_exports.string()
 });
+var WaitCreatedEventSchema = BaseEventSchema.extend({
+    eventType: external_exports.literal("wait_created"),
+    correlationId: external_exports.string(),
+    eventData: external_exports.object({
+        resumeAt: external_exports.coerce.date()
+    })
+});
+var WaitCompletedEventSchema = BaseEventSchema.extend({
+    eventType: external_exports.literal("wait_completed"),
+    correlationId: external_exports.string()
+});
 var WorkflowCompletedEventSchema = BaseEventSchema.extend({
     eventType: external_exports.literal("workflow_completed")
 });
@@ -18557,6 +18161,8 @@ var CreateEventSchema = external_exports.discriminatedUnion("eventType", [
     HookCreatedEventSchema,
     HookReceivedEventSchema,
     HookDisposedEventSchema,
+    WaitCreatedEventSchema,
+    WaitCompletedEventSchema,
     WorkflowCompletedEventSchema,
     WorkflowFailedEventSchema,
     WorkflowStartedEventSchema
@@ -18661,7 +18267,8 @@ var StepSchema = external_exports.object({
     startedAt: external_exports.coerce.date().optional(),
     completedAt: external_exports.coerce.date().optional(),
     createdAt: external_exports.coerce.date(),
-    updatedAt: external_exports.coerce.date()
+    updatedAt: external_exports.coerce.date(),
+    retryAfter: external_exports.coerce.date().optional()
 });
 // ../../node_modules/.pnpm/ulid@3.0.1/node_modules/ulid/dist/node/index.js
 var import_node_crypto = __toESM(require("node:crypto"), 1);
@@ -18714,933 +18321,1390 @@ function incrementBase32(str) {
         if (charIndex === -1) {
             throw new ULIDError(ULIDErrorCode.Base32IncorrectEncoding, "Incorrectly encoded string");
         }
-        if (charIndex === maxCharIndex) {
-            output = replaceCharAt(output, index, ENCODING[0]);
-            continue;
+        if (charIndex === maxCharIndex) {
+            output = replaceCharAt(output, index, ENCODING[0]);
+            continue;
+        }
+        done = replaceCharAt(output, index, ENCODING[charIndex + 1]);
+    }
+    if (typeof done === "string") {
+        return done;
+    }
+    throw new ULIDError(ULIDErrorCode.Base32IncorrectEncoding, "Failed incrementing string");
+}
+__name(incrementBase32, "incrementBase32");
+function decodeTime(id) {
+    if (id.length !== TIME_LEN + RANDOM_LEN) {
+        throw new ULIDError(ULIDErrorCode.DecodeTimeValueMalformed, "Malformed ULID");
+    }
+    const time3 = id.substr(0, TIME_LEN).toUpperCase().split("").reverse().reduce((carry, char, index) => {
+        const encodingIndex = ENCODING.indexOf(char);
+        if (encodingIndex === -1) {
+            throw new ULIDError(ULIDErrorCode.DecodeTimeInvalidCharacter, `Time decode error: Invalid character: ${char}`);
+        }
+        return carry += encodingIndex * Math.pow(ENCODING_LEN, index);
+    }, 0);
+    if (time3 > TIME_MAX) {
+        throw new ULIDError(ULIDErrorCode.DecodeTimeValueMalformed, `Malformed ULID: timestamp too large: ${time3}`);
+    }
+    return time3;
+}
+__name(decodeTime, "decodeTime");
+function detectPRNG(root) {
+    const rootLookup = detectRoot();
+    const globalCrypto = rootLookup && (rootLookup.crypto || rootLookup.msCrypto) || (typeof import_node_crypto.default !== "undefined" ? import_node_crypto.default : null);
+    if (typeof globalCrypto?.getRandomValues === "function") {
+        return () => {
+            const buffer = new Uint8Array(1);
+            globalCrypto.getRandomValues(buffer);
+            return buffer[0] / 255;
+        };
+    }
+    else if (typeof globalCrypto?.randomBytes === "function") {
+        return () => globalCrypto.randomBytes(1).readUInt8() / 255;
+    }
+    else if (import_node_crypto.default?.randomBytes) {
+        return () => import_node_crypto.default.randomBytes(1).readUInt8() / 255;
+    }
+    throw new ULIDError(ULIDErrorCode.PRNGDetectFailure, "Failed to find a reliable PRNG");
+}
+__name(detectPRNG, "detectPRNG");
+function detectRoot() {
+    if (inWebWorker())
+        return self;
+    if (typeof window !== "undefined") {
+        return window;
+    }
+    if (typeof global !== "undefined") {
+        return global;
+    }
+    if (typeof globalThis !== "undefined") {
+        return globalThis;
+    }
+    return null;
+}
+__name(detectRoot, "detectRoot");
+function encodeRandom(len, prng) {
+    let str = "";
+    for (; len > 0; len--) {
+        str = randomChar(prng) + str;
+    }
+    return str;
+}
+__name(encodeRandom, "encodeRandom");
+function encodeTime(now, len = TIME_LEN) {
+    if (isNaN(now)) {
+        throw new ULIDError(ULIDErrorCode.EncodeTimeValueMalformed, `Time must be a number: ${now}`);
+    }
+    else if (now > TIME_MAX) {
+        throw new ULIDError(ULIDErrorCode.EncodeTimeSizeExceeded, `Cannot encode a time larger than ${TIME_MAX}: ${now}`);
+    }
+    else if (now < 0) {
+        throw new ULIDError(ULIDErrorCode.EncodeTimeNegative, `Time must be positive: ${now}`);
+    }
+    else if (Number.isInteger(now) === false) {
+        throw new ULIDError(ULIDErrorCode.EncodeTimeValueMalformed, `Time must be an integer: ${now}`);
+    }
+    let mod, str = "";
+    for (let currentLen = len; currentLen > 0; currentLen--) {
+        mod = now % ENCODING_LEN;
+        str = ENCODING.charAt(mod) + str;
+        now = (now - mod) / ENCODING_LEN;
+    }
+    return str;
+}
+__name(encodeTime, "encodeTime");
+function inWebWorker() {
+    return typeof WorkerGlobalScope !== "undefined" && self instanceof WorkerGlobalScope;
+}
+__name(inWebWorker, "inWebWorker");
+function monotonicFactory(prng) {
+    const currentPRNG = prng || detectPRNG();
+    let lastTime = 0, lastRandom;
+    return /* @__PURE__ */ __name(function _ulid2(seedTime) {
+        const seed = !seedTime || isNaN(seedTime) ? Date.now() : seedTime;
+        if (seed <= lastTime) {
+            const incrementedRandom = lastRandom = incrementBase32(lastRandom);
+            return encodeTime(lastTime, TIME_LEN) + incrementedRandom;
+        }
+        lastTime = seed;
+        const newRandom = lastRandom = encodeRandom(RANDOM_LEN, currentPRNG);
+        return encodeTime(seed, TIME_LEN) + newRandom;
+    }, "_ulid");
+}
+__name(monotonicFactory, "monotonicFactory");
+// ../world-local/dist/queue.js
+var LOCAL_QUEUE_MAX_VISIBILITY = parseInt(process.env.WORKFLOW_LOCAL_QUEUE_MAX_VISIBILITY ?? "0", 10) || Infinity;
+function createQueue(port) {
+    const transport = new JsonTransport();
+    const generateId = monotonicFactory();
+    const inflightMessages = /* @__PURE__ */ new Map();
+    const queue = /* @__PURE__ */ __name(async (queueName, message, opts) => {
+        const cleanup = [];
+        if (opts?.idempotencyKey) {
+            const existing = inflightMessages.get(opts.idempotencyKey);
+            if (existing) {
+                return { messageId: existing };
+            }
+        }
+        const body = transport.serialize(message);
+        let pathname;
+        if (queueName.startsWith("__wkf_step_")) {
+            pathname = `step`;
+        }
+        else if (queueName.startsWith("__wkf_workflow_")) {
+            pathname = `flow`;
+        }
+        else {
+            throw new Error("Unknown queue name prefix");
+        }
+        const messageId = MessageId.parse(`msg_${generateId()}`);
+        if (opts?.idempotencyKey) {
+            const key = opts.idempotencyKey;
+            inflightMessages.set(key, messageId);
+            cleanup.push(() => {
+                inflightMessages.delete(key);
+            });
+        }
+        (async () => {
+            let defaultRetriesLeft = 3;
+            for (let attempt = 0; defaultRetriesLeft > 0; attempt++) {
+                defaultRetriesLeft--;
+                const response = await fetch(`http://localhost:${port}/.well-known/workflow/v1/${pathname}`, {
+                    method: "POST",
+                    duplex: "half",
+                    headers: {
+                        "x-vqs-queue-name": queueName,
+                        "x-vqs-message-id": messageId,
+                        "x-vqs-message-attempt": String(attempt + 1)
+                    },
+                    body
+                });
+                if (response.ok) {
+                    return;
+                }
+                const text = await response.text();
+                if (response.status === 503) {
+                    try {
+                        const timeoutSeconds = Number(JSON.parse(text).timeoutSeconds);
+                        await (0, import_promises.setTimeout)(timeoutSeconds * 1e3);
+                        defaultRetriesLeft++;
+                        continue;
+                    }
+                    catch {
+                    }
+                }
+                console.error(`[embedded world] Failed to queue message`, {
+                    queueName,
+                    text,
+                    status: response.status,
+                    headers: Object.fromEntries(response.headers.entries()),
+                    body: body.toString()
+                });
+            }
+            console.error(`[embedded world] Reached max retries of embedded world queue implementation`);
+        })().finally(() => {
+            for (const fn of cleanup) {
+                fn();
+            }
+        });
+        return { messageId };
+    }, "queue");
+    const HeaderParser = zod_default.object({
+        "x-vqs-queue-name": ValidQueueName,
+        "x-vqs-message-id": MessageId,
+        "x-vqs-message-attempt": zod_default.coerce.number()
+    });
+    const createQueueHandler = /* @__PURE__ */ __name((prefix, handler) => {
+        return async (req) => {
+            const headers = HeaderParser.safeParse(Object.fromEntries(req.headers));
+            if (!headers.success || !req.body) {
+                return Response.json({ error: "Missing required headers" }, { status: 400 });
+            }
+            const queueName = headers.data["x-vqs-queue-name"];
+            const messageId = headers.data["x-vqs-message-id"];
+            const attempt = headers.data["x-vqs-message-attempt"];
+            if (!queueName.startsWith(prefix)) {
+                return Response.json({ error: "Unhandled queue" }, { status: 400 });
+            }
+            const body = await new JsonTransport().deserialize(req.body);
+            try {
+                const result = await handler(body, { attempt, queueName, messageId });
+                let timeoutSeconds = null;
+                if (typeof result?.timeoutSeconds === "number") {
+                    timeoutSeconds = Math.min(result.timeoutSeconds, LOCAL_QUEUE_MAX_VISIBILITY);
+                }
+                if (timeoutSeconds) {
+                    return Response.json({ timeoutSeconds }, { status: 503 });
+                }
+                return Response.json({ ok: true });
+            }
+            catch (error45) {
+                return Response.json(String(error45), { status: 500 });
+            }
+        };
+    }, "createQueueHandler");
+    const getDeploymentId = /* @__PURE__ */ __name(async () => {
+        return "dpl_embedded";
+    }, "getDeploymentId");
+    return { queue, createQueueHandler, getDeploymentId };
+}
+__name(createQueue, "createQueue");
+// ../world-local/dist/storage.js
+var import_node_path2 = __toESM(require("node:path"), 1);
+// ../world-local/dist/fs.js
+var import_node_fs = require("node:fs");
+var import_node_path = __toESM(require("node:path"), 1);
+var ulid3 = monotonicFactory(() => Math.random());
+var Ulid = external_exports.string().ulid();
+function ulidToDate(maybeUlid) {
+    const ulid4 = Ulid.safeParse(maybeUlid);
+    if (!ulid4.success) {
+        return null;
+    }
+    return new Date(decodeTime(ulid4.data));
+}
+__name(ulidToDate, "ulidToDate");
+async function ensureDir(dirPath) {
+    try {
+        await import_node_fs.promises.mkdir(dirPath, { recursive: true });
+    }
+    catch (_error) {
+    }
+}
+__name(ensureDir, "ensureDir");
+async function writeJSON(filePath, data, opts) {
+    return write(filePath, JSON.stringify(data, null, 2), opts);
+}
+__name(writeJSON, "writeJSON");
+async function write(filePath, data, opts) {
+    if (!opts?.overwrite) {
+        try {
+            await import_node_fs.promises.access(filePath);
+            throw new WorkflowAPIError(`File ${filePath} already exists and 'overwrite' is false`, { status: 409 });
+        }
+        catch (error45) {
+            if (error45.code !== "ENOENT") {
+                throw error45;
+            }
         }
-        done = replaceCharAt(output, index, ENCODING[charIndex + 1]);
     }
-    if (typeof done === "string") {
-        return done;
+    const tempPath = `${filePath}.tmp.${ulid3()}`;
+    try {
+        await ensureDir(import_node_path.default.dirname(filePath));
+        await import_node_fs.promises.writeFile(tempPath, data);
+        await import_node_fs.promises.rename(tempPath, filePath);
+    }
+    catch (error45) {
+        await import_node_fs.promises.unlink(tempPath).catch(() => {
+        });
+        throw error45;
     }
-    throw new ULIDError(ULIDErrorCode.Base32IncorrectEncoding, "Failed incrementing string");
 }
-__name(incrementBase32, "incrementBase32");
-function decodeTime(id) {
-    if (id.length !== TIME_LEN + RANDOM_LEN) {
-        throw new ULIDError(ULIDErrorCode.DecodeTimeValueMalformed, "Malformed ULID");
+__name(write, "write");
+async function readJSON(filePath, decoder) {
+    try {
+        const content = await import_node_fs.promises.readFile(filePath, "utf-8");
+        return decoder.parse(JSON.parse(content));
     }
-    const time3 = id.substr(0, TIME_LEN).toUpperCase().split("").reverse().reduce((carry, char, index) => {
-        const encodingIndex = ENCODING.indexOf(char);
-        if (encodingIndex === -1) {
-            throw new ULIDError(ULIDErrorCode.DecodeTimeInvalidCharacter, `Time decode error: Invalid character: ${char}`);
-        }
-        return carry += encodingIndex * Math.pow(ENCODING_LEN, index);
-    }, 0);
-    if (time3 > TIME_MAX) {
-        throw new ULIDError(ULIDErrorCode.DecodeTimeValueMalformed, `Malformed ULID: timestamp too large: ${time3}`);
+    catch (error45) {
+        if (error45.code === "ENOENT")
+            return null;
+        throw error45;
     }
-    return time3;
 }
-__name(decodeTime, "decodeTime");
-function detectPRNG(root) {
-    const rootLookup = detectRoot();
-    const globalCrypto = rootLookup && (rootLookup.crypto || rootLookup.msCrypto) || (typeof import_node_crypto.default !== "undefined" ? import_node_crypto.default : null);
-    if (typeof globalCrypto?.getRandomValues === "function") {
-        return () => {
-            const buffer = new Uint8Array(1);
-            globalCrypto.getRandomValues(buffer);
-            return buffer[0] / 255;
-        };
-    }
-    else if (typeof globalCrypto?.randomBytes === "function") {
-        return () => globalCrypto.randomBytes(1).readUInt8() / 255;
+__name(readJSON, "readJSON");
+async function readBuffer(filePath) {
+    const content = await import_node_fs.promises.readFile(filePath);
+    return content;
+}
+__name(readBuffer, "readBuffer");
+async function deleteJSON(filePath) {
+    try {
+        await import_node_fs.promises.unlink(filePath);
     }
-    else if (import_node_crypto.default?.randomBytes) {
-        return () => import_node_crypto.default.randomBytes(1).readUInt8() / 255;
+    catch (error45) {
+        if (error45.code !== "ENOENT")
+            throw error45;
     }
-    throw new ULIDError(ULIDErrorCode.PRNGDetectFailure, "Failed to find a reliable PRNG");
 }
-__name(detectPRNG, "detectPRNG");
-function detectRoot() {
-    if (inWebWorker())
-        return self;
-    if (typeof window !== "undefined") {
-        return window;
-    }
-    if (typeof global !== "undefined") {
-        return global;
+__name(deleteJSON, "deleteJSON");
+async function listJSONFiles(dirPath) {
+    try {
+        const files = await import_node_fs.promises.readdir(dirPath);
+        return files.filter((f) => f.endsWith(".json")).map((f) => f.replace(".json", ""));
     }
-    if (typeof globalThis !== "undefined") {
-        return globalThis;
+    catch (error45) {
+        if (error45.code === "ENOENT")
+            return [];
+        throw error45;
     }
-    return null;
 }
-__name(detectRoot, "detectRoot");
-function encodeRandom(len, prng) {
-    let str = "";
-    for (; len > 0; len--) {
-        str = randomChar(prng) + str;
-    }
-    return str;
+__name(listJSONFiles, "listJSONFiles");
+function parseCursor(cursor) {
+    if (!cursor)
+        return null;
+    const parts = cursor.split("|");
+    return {
+        timestamp: new Date(parts[0]),
+        id: parts[1] || null
+    };
 }
-__name(encodeRandom, "encodeRandom");
-function encodeTime(now, len = TIME_LEN) {
-    if (isNaN(now)) {
-        throw new ULIDError(ULIDErrorCode.EncodeTimeValueMalformed, `Time must be a number: ${now}`);
-    }
-    else if (now > TIME_MAX) {
-        throw new ULIDError(ULIDErrorCode.EncodeTimeSizeExceeded, `Cannot encode a time larger than ${TIME_MAX}: ${now}`);
+__name(parseCursor, "parseCursor");
+function createCursor(timestamp, id) {
+    return id ? `${timestamp.toISOString()}|${id}` : timestamp.toISOString();
+}
+__name(createCursor, "createCursor");
+async function paginatedFileSystemQuery(config3) {
+    const { directory, schema, filePrefix, filter, sortOrder = "desc", limit = 20, cursor, getCreatedAt, getId } = config3;
+    const fileIds = await listJSONFiles(directory);
+    const relevantFileIds = filePrefix ? fileIds.filter((fileId) => fileId.startsWith(filePrefix)) : fileIds;
+    const parsedCursor = parseCursor(cursor);
+    let candidateFileIds = relevantFileIds;
+    if (parsedCursor) {
+        candidateFileIds = relevantFileIds.filter((fileId) => {
+            const filenameDate = getCreatedAt(`${fileId}.json`);
+            if (filenameDate) {
+                const cursorTime = parsedCursor.timestamp.getTime();
+                const fileTime = filenameDate.getTime();
+                if (parsedCursor.id) {
+                    return sortOrder === "desc" ? fileTime <= cursorTime : fileTime >= cursorTime;
+                }
+                else {
+                    return sortOrder === "desc" ? fileTime < cursorTime : fileTime > cursorTime;
+                }
+            }
+            return false;
+        });
     }
-    else if (now < 0) {
-        throw new ULIDError(ULIDErrorCode.EncodeTimeNegative, `Time must be positive: ${now}`);
+    else {
+        candidateFileIds = relevantFileIds.filter((fileId) => {
+            return getCreatedAt(`${fileId}.json`) !== null;
+        });
     }
-    else if (Number.isInteger(now) === false) {
-        throw new ULIDError(ULIDErrorCode.EncodeTimeValueMalformed, `Time must be an integer: ${now}`);
+    const validItems = [];
+    for (const fileId of candidateFileIds) {
+        const filePath = import_node_path.default.join(directory, `${fileId}.json`);
+        const item = await readJSON(filePath, schema);
+        if (item) {
+            if (filter && !filter(item))
+                continue;
+            if (parsedCursor) {
+                const itemTime = item.createdAt.getTime();
+                const cursorTime = parsedCursor.timestamp.getTime();
+                if (sortOrder === "desc") {
+                    if (itemTime > cursorTime)
+                        continue;
+                    if (itemTime === cursorTime && parsedCursor.id && getId) {
+                        const itemId = getId(item);
+                        if (itemId >= parsedCursor.id)
+                            continue;
+                    }
+                }
+                else {
+                    if (itemTime < cursorTime)
+                        continue;
+                    if (itemTime === cursorTime && parsedCursor.id && getId) {
+                        const itemId = getId(item);
+                        if (itemId <= parsedCursor.id)
+                            continue;
+                    }
+                }
+            }
+            validItems.push(item);
+        }
     }
-    let mod, str = "";
-    for (let currentLen = len; currentLen > 0; currentLen--) {
-        mod = now % ENCODING_LEN;
-        str = ENCODING.charAt(mod) + str;
-        now = (now - mod) / ENCODING_LEN;
+    validItems.sort((a, b) => {
+        const aTime = a.createdAt.getTime();
+        const bTime = b.createdAt.getTime();
+        const timeComparison = sortOrder === "asc" ? aTime - bTime : bTime - aTime;
+        if (timeComparison === 0 && getId) {
+            const aId = getId(a);
+            const bId = getId(b);
+            return sortOrder === "asc" ? aId.localeCompare(bId) : bId.localeCompare(aId);
+        }
+        return timeComparison;
+    });
+    const hasMore = validItems.length > limit;
+    const items = hasMore ? validItems.slice(0, limit) : validItems;
+    const nextCursor = hasMore && items.length > 0 ? createCursor(items[items.length - 1].createdAt, getId?.(items[items.length - 1])) : null;
+    return {
+        data: items,
+        cursor: nextCursor,
+        hasMore
+    };
+}
+__name(paginatedFileSystemQuery, "paginatedFileSystemQuery");
+// ../world-local/dist/storage.js
+var monotonicUlid = monotonicFactory(() => Math.random());
+function filterRunData(run, resolveData) {
+    if (resolveData === "none") {
+        return {
+            ...run,
+            input: [],
+            output: void 0
+        };
     }
-    return str;
+    return run;
 }
-__name(encodeTime, "encodeTime");
-function inWebWorker() {
-    return typeof WorkerGlobalScope !== "undefined" && self instanceof WorkerGlobalScope;
+__name(filterRunData, "filterRunData");
+function filterStepData(step, resolveData) {
+    if (resolveData === "none") {
+        return {
+            ...step,
+            input: [],
+            output: void 0
+        };
+    }
+    return step;
 }
-__name(inWebWorker, "inWebWorker");
-function monotonicFactory(prng) {
-    const currentPRNG = prng || detectPRNG();
-    let lastTime = 0, lastRandom;
-    return /* @__PURE__ */ __name(function _ulid2(seedTime) {
-        const seed = !seedTime || isNaN(seedTime) ? Date.now() : seedTime;
-        if (seed <= lastTime) {
-            const incrementedRandom = lastRandom = incrementBase32(lastRandom);
-            return encodeTime(lastTime, TIME_LEN) + incrementedRandom;
-        }
-        lastTime = seed;
-        const newRandom = lastRandom = encodeRandom(RANDOM_LEN, currentPRNG);
-        return encodeTime(seed, TIME_LEN) + newRandom;
-    }, "_ulid");
+__name(filterStepData, "filterStepData");
+function filterEventData(event, resolveData) {
+    if (resolveData === "none") {
+        const { eventData: _eventData, ...rest } = event;
+        return rest;
+    }
+    return event;
 }
-__name(monotonicFactory, "monotonicFactory");
-// ../world-local/dist/queue.js
-function createQueue(port) {
-    const transport = new JsonTransport();
-    const generateId = monotonicFactory();
-    const inflightMessages = /* @__PURE__ */ new Map();
-    const queue = /* @__PURE__ */ __name(async (queueName, message, opts) => {
-        const cleanup = [];
-        if (opts?.idempotencyKey) {
-            const existing = inflightMessages.get(opts.idempotencyKey);
-            if (existing) {
-                return { messageId: existing };
+__name(filterEventData, "filterEventData");
+function filterHookData(hook, resolveData) {
+    if (resolveData === "none") {
+        const { metadata: _metadata, ...rest } = hook;
+        return rest;
+    }
+    return hook;
+}
+__name(filterHookData, "filterHookData");
+var getObjectCreatedAt = /* @__PURE__ */ __name((idPrefix) => (filename) => {
+    const replaceRegex = new RegExp(`^${idPrefix}_`, "g");
+    const dashIndex = filename.indexOf("-");
+    if (dashIndex === -1) {
+        const ulid5 = filename.replace(/\.json$/, "").replace(replaceRegex, "");
+        return ulidToDate(ulid5);
+    }
+    if (idPrefix === "step") {
+        const runId = filename.substring(0, dashIndex);
+        const ulid5 = runId.replace(/^wrun_/, "");
+        return ulidToDate(ulid5);
+    }
+    const id = filename.substring(dashIndex + 1).replace(/\.json$/, "");
+    const ulid4 = id.replace(replaceRegex, "");
+    return ulidToDate(ulid4);
+}, "getObjectCreatedAt");
+function createStorage(basedir) {
+    return {
+        runs: {
+            async create(data) {
+                const runId = `wrun_${monotonicUlid()}`;
+                const now = /* @__PURE__ */ new Date();
+                const result = {
+                    runId,
+                    deploymentId: data.deploymentId,
+                    status: "pending",
+                    workflowName: data.workflowName,
+                    executionContext: data.executionContext,
+                    input: data.input || [],
+                    output: void 0,
+                    error: void 0,
+                    errorCode: void 0,
+                    startedAt: void 0,
+                    completedAt: void 0,
+                    createdAt: now,
+                    updatedAt: now
+                };
+                const runPath = import_node_path2.default.join(basedir, "runs", `${runId}.json`);
+                await writeJSON(runPath, result);
+                return result;
+            },
+            async get(id, params) {
+                const runPath = import_node_path2.default.join(basedir, "runs", `${id}.json`);
+                const run = await readJSON(runPath, WorkflowRunSchema);
+                if (!run) {
+                    throw new WorkflowRunNotFoundError(id);
+                }
+                const resolveData = params?.resolveData ?? DEFAULT_RESOLVE_DATA_OPTION;
+                return filterRunData(run, resolveData);
+            },
+            async update(id, data) {
+                const runPath = import_node_path2.default.join(basedir, "runs", `${id}.json`);
+                const run = await readJSON(runPath, WorkflowRunSchema);
+                if (!run) {
+                    throw new WorkflowRunNotFoundError(id);
+                }
+                const now = /* @__PURE__ */ new Date();
+                const updatedRun = {
+                    ...run,
+                    ...data,
+                    updatedAt: now
+                };
+                if (data.status === "running" && !updatedRun.startedAt) {
+                    updatedRun.startedAt = now;
+                }
+                if (data.status === "completed" || data.status === "failed" || data.status === "cancelled") {
+                    updatedRun.completedAt = now;
+                }
+                await writeJSON(runPath, updatedRun, { overwrite: true });
+                return updatedRun;
+            },
+            async list(params) {
+                const resolveData = params?.resolveData ?? DEFAULT_RESOLVE_DATA_OPTION;
+                const result = await paginatedFileSystemQuery({
+                    directory: import_node_path2.default.join(basedir, "runs"),
+                    schema: WorkflowRunSchema,
+                    filter: /* @__PURE__ */ __name((run) => {
+                        if (params?.workflowName && run.workflowName !== params.workflowName) {
+                            return false;
+                        }
+                        if (params?.status && run.status !== params.status) {
+                            return false;
+                        }
+                        return true;
+                    }, "filter"),
+                    sortOrder: params?.pagination?.sortOrder ?? "desc",
+                    limit: params?.pagination?.limit,
+                    cursor: params?.pagination?.cursor,
+                    getCreatedAt: getObjectCreatedAt("wrun"),
+                    getId: /* @__PURE__ */ __name((run) => run.runId, "getId")
+                });
+                if (resolveData === "none") {
+                    return {
+                        ...result,
+                        data: result.data.map((run) => ({
+                            ...run,
+                            input: [],
+                            output: void 0
+                        }))
+                    };
+                }
+                return result;
+            },
+            async cancel(id, params) {
+                const run = await this.update(id, { status: "cancelled" });
+                const resolveData = params?.resolveData ?? DEFAULT_RESOLVE_DATA_OPTION;
+                return filterRunData(run, resolveData);
+            },
+            async pause(id, params) {
+                const run = await this.update(id, { status: "paused" });
+                const resolveData = params?.resolveData ?? DEFAULT_RESOLVE_DATA_OPTION;
+                return filterRunData(run, resolveData);
+            },
+            async resume(id, params) {
+                const run = await this.update(id, { status: "running" });
+                const resolveData = params?.resolveData ?? DEFAULT_RESOLVE_DATA_OPTION;
+                return filterRunData(run, resolveData);
             }
-        }
-        const body = transport.serialize(message);
-        let pathname;
-        if (queueName.startsWith("__wkf_step_")) {
-            pathname = `step`;
-        }
-        else if (queueName.startsWith("__wkf_workflow_")) {
-            pathname = `flow`;
-        }
-        else {
-            throw new Error("Unknown queue name prefix");
-        }
-        const messageId = MessageId.parse(`msg_${generateId()}`);
-        if (opts?.idempotencyKey) {
-            const key = opts.idempotencyKey;
-            inflightMessages.set(key, messageId);
-            cleanup.push(() => {
-                inflightMessages.delete(key);
-            });
-        }
-        (async () => {
-            let defaultRetriesLeft = 3;
-            for (let attempt = 0; defaultRetriesLeft > 0; attempt++) {
-                defaultRetriesLeft--;
-                const response = await fetch(`http://localhost:${port}/.well-known/workflow/v1/${pathname}`, {
-                    method: "POST",
-                    duplex: "half",
-                    headers: {
-                        "x-vqs-queue-name": queueName,
-                        "x-vqs-message-id": messageId,
-                        "x-vqs-message-attempt": String(attempt + 1)
-                    },
-                    body
+        },
+        steps: {
+            async create(runId, data) {
+                const now = /* @__PURE__ */ new Date();
+                const result = {
+                    runId,
+                    stepId: data.stepId,
+                    stepName: data.stepName,
+                    status: "pending",
+                    input: data.input,
+                    output: void 0,
+                    error: void 0,
+                    errorCode: void 0,
+                    attempt: 0,
+                    startedAt: void 0,
+                    completedAt: void 0,
+                    createdAt: now,
+                    updatedAt: now
+                };
+                const compositeKey = `${runId}-${data.stepId}`;
+                const stepPath = import_node_path2.default.join(basedir, "steps", `${compositeKey}.json`);
+                await writeJSON(stepPath, result);
+                return result;
+            },
+            async get(runId, stepId, params) {
+                if (!runId) {
+                    const fileIds = await listJSONFiles(import_node_path2.default.join(basedir, "steps"));
+                    const fileId = fileIds.find((fileId2) => fileId2.endsWith(`-${stepId}`));
+                    if (!fileId) {
+                        throw new Error(`Step ${stepId} not found`);
+                    }
+                    runId = fileId.split("-")[0];
+                }
+                const compositeKey = `${runId}-${stepId}`;
+                const stepPath = import_node_path2.default.join(basedir, "steps", `${compositeKey}.json`);
+                const step = await readJSON(stepPath, StepSchema);
+                if (!step) {
+                    throw new Error(`Step ${stepId} in run ${runId} not found`);
+                }
+                const resolveData = params?.resolveData ?? DEFAULT_RESOLVE_DATA_OPTION;
+                return filterStepData(step, resolveData);
+            },
+            async update(runId, stepId, data) {
+                const compositeKey = `${runId}-${stepId}`;
+                const stepPath = import_node_path2.default.join(basedir, "steps", `${compositeKey}.json`);
+                const step = await readJSON(stepPath, StepSchema);
+                if (!step) {
+                    throw new Error(`Step ${stepId} in run ${runId} not found`);
+                }
+                const now = /* @__PURE__ */ new Date();
+                const updatedStep = {
+                    ...step,
+                    ...data,
+                    updatedAt: now
+                };
+                if (data.status === "running" && !updatedStep.startedAt) {
+                    updatedStep.startedAt = now;
+                }
+                if (data.status === "completed" || data.status === "failed") {
+                    updatedStep.completedAt = now;
+                }
+                await writeJSON(stepPath, updatedStep, { overwrite: true });
+                return updatedStep;
+            },
+            async list(params) {
+                const resolveData = params.resolveData ?? DEFAULT_RESOLVE_DATA_OPTION;
+                const result = await paginatedFileSystemQuery({
+                    directory: import_node_path2.default.join(basedir, "steps"),
+                    schema: StepSchema,
+                    filePrefix: `${params.runId}-`,
+                    sortOrder: params.pagination?.sortOrder ?? "desc",
+                    limit: params.pagination?.limit,
+                    cursor: params.pagination?.cursor,
+                    getCreatedAt: getObjectCreatedAt("step"),
+                    getId: /* @__PURE__ */ __name((step) => step.stepId, "getId")
+                });
+                if (resolveData === "none") {
+                    return {
+                        ...result,
+                        data: result.data.map((step) => ({
+                            ...step,
+                            input: [],
+                            output: void 0
+                        }))
+                    };
+                }
+                return result;
+            }
+        },
+        // Events - filesystem-backed storage
+        events: {
+            async create(runId, data, params) {
+                const eventId = `evnt_${monotonicUlid()}`;
+                const now = /* @__PURE__ */ new Date();
+                const result = {
+                    ...data,
+                    runId,
+                    eventId,
+                    createdAt: now
+                };
+                const compositeKey = `${runId}-${eventId}`;
+                const eventPath = import_node_path2.default.join(basedir, "events", `${compositeKey}.json`);
+                await writeJSON(eventPath, result);
+                const resolveData = params?.resolveData ?? DEFAULT_RESOLVE_DATA_OPTION;
+                return filterEventData(result, resolveData);
+            },
+            async list(params) {
+                const { runId } = params;
+                const resolveData = params.resolveData ?? DEFAULT_RESOLVE_DATA_OPTION;
+                const result = await paginatedFileSystemQuery({
+                    directory: import_node_path2.default.join(basedir, "events"),
+                    schema: EventSchema,
+                    filePrefix: `${runId}-`,
+                    // Events in chronological order (oldest first) by default,
+                    // different from the default for other list calls.
+                    sortOrder: params.pagination?.sortOrder ?? "asc",
+                    limit: params.pagination?.limit,
+                    cursor: params.pagination?.cursor,
+                    getCreatedAt: getObjectCreatedAt("evnt"),
+                    getId: /* @__PURE__ */ __name((event) => event.eventId, "getId")
                 });
-                if (response.ok) {
-                    return;
+                if (resolveData === "none") {
+                    return {
+                        ...result,
+                        data: result.data.map((event) => {
+                            const { eventData: _eventData, ...rest } = event;
+                            return rest;
+                        })
+                    };
                 }
-                const text = await response.text();
-                if (response.status === 503) {
-                    try {
-                        const retryIn = Number(JSON.parse(text).retryIn);
-                        await (0, import_promises.setTimeout)(retryIn * 1e3);
-                        defaultRetriesLeft++;
-                        continue;
-                    }
-                    catch {
+                return result;
+            },
+            async listByCorrelationId(params) {
+                const correlationId = params.correlationId;
+                const resolveData = params.resolveData ?? DEFAULT_RESOLVE_DATA_OPTION;
+                const result = await paginatedFileSystemQuery({
+                    directory: import_node_path2.default.join(basedir, "events"),
+                    schema: EventSchema,
+                    // No filePrefix - search all events
+                    filter: /* @__PURE__ */ __name((event) => event.correlationId === correlationId, "filter"),
+                    // Events in chronological order (oldest first) by default,
+                    // different from the default for other list calls.
+                    sortOrder: params.pagination?.sortOrder ?? "asc",
+                    limit: params.pagination?.limit,
+                    cursor: params.pagination?.cursor,
+                    getCreatedAt: getObjectCreatedAt("evnt"),
+                    getId: /* @__PURE__ */ __name((event) => event.eventId, "getId")
+                });
+                if (resolveData === "none") {
+                    return {
+                        ...result,
+                        data: result.data.map((event) => {
+                            const { eventData: _eventData, ...rest } = event;
+                            return rest;
+                        })
+                    };
+                }
+                return result;
+            }
+        },
+        // Hooks
+        hooks: {
+            async create(runId, data) {
+                const now = /* @__PURE__ */ new Date();
+                const result = {
+                    runId,
+                    hookId: data.hookId,
+                    token: data.token,
+                    metadata: data.metadata,
+                    ownerId: "embedded-owner",
+                    projectId: "embedded-project",
+                    environment: "embedded",
+                    createdAt: now
+                };
+                const hookPath = import_node_path2.default.join(basedir, "hooks", `${data.hookId}.json`);
+                await writeJSON(hookPath, result);
+                return result;
+            },
+            async get(hookId, params) {
+                const hookPath = import_node_path2.default.join(basedir, "hooks", `${hookId}.json`);
+                const hook = await readJSON(hookPath, HookSchema);
+                if (!hook) {
+                    throw new Error(`Hook ${hookId} not found`);
+                }
+                const resolveData = params?.resolveData || DEFAULT_RESOLVE_DATA_OPTION;
+                return filterHookData(hook, resolveData);
+            },
+            async getByToken(token) {
+                const hooksDir = import_node_path2.default.join(basedir, "hooks");
+                const files = await listJSONFiles(hooksDir);
+                for (const file2 of files) {
+                    const hookPath = import_node_path2.default.join(hooksDir, `${file2}.json`);
+                    const hook = await readJSON(hookPath, HookSchema);
+                    if (hook && hook.token === token) {
+                        return hook;
                     }
                 }
-                console.error(`[embedded world] Failed to queue message`, {
-                    queueName,
-                    text,
-                    status: response.status,
-                    headers: Object.fromEntries(response.headers.entries()),
-                    body: body.toString()
+                throw new Error(`Hook with token ${token} not found`);
+            },
+            async list(params) {
+                const hooksDir = import_node_path2.default.join(basedir, "hooks");
+                const resolveData = params.resolveData || DEFAULT_RESOLVE_DATA_OPTION;
+                const result = await paginatedFileSystemQuery({
+                    directory: hooksDir,
+                    schema: HookSchema,
+                    sortOrder: params.pagination?.sortOrder,
+                    limit: params.pagination?.limit,
+                    cursor: params.pagination?.cursor,
+                    filePrefix: void 0,
+                    // Hooks don't have ULIDs, so we can't optimize by filename
+                    filter: /* @__PURE__ */ __name((hook) => {
+                        if (params.runId && hook.runId !== params.runId) {
+                            return false;
+                        }
+                        return true;
+                    }, "filter"),
+                    getCreatedAt: /* @__PURE__ */ __name(() => {
+                        return /* @__PURE__ */ new Date(0);
+                    }, "getCreatedAt"),
+                    getId: /* @__PURE__ */ __name((hook) => hook.hookId, "getId")
                 });
+                return {
+                    ...result,
+                    data: result.data.map((hook) => filterHookData(hook, resolveData))
+                };
+            },
+            async dispose(hookId) {
+                const hookPath = import_node_path2.default.join(basedir, "hooks", `${hookId}.json`);
+                const hook = await readJSON(hookPath, HookSchema);
+                if (!hook) {
+                    throw new Error(`Hook ${hookId} not found`);
+                }
+                await deleteJSON(hookPath);
+                return hook;
             }
-            console.error(`[embedded world] Reached max retries of embedded world queue implementation`);
-        })().finally(() => {
-            for (const fn of cleanup) {
-                fn();
-            }
-        });
-        return { messageId };
-    }, "queue");
-    const HeaderParser = zod_default.object({
-        "x-vqs-queue-name": ValidQueueName,
-        "x-vqs-message-id": MessageId,
-        "x-vqs-message-attempt": zod_default.coerce.number()
-    });
-    const createQueueHandler = /* @__PURE__ */ __name((prefix, handler) => {
-        return async (req) => {
-            const headers = HeaderParser.safeParse(Object.fromEntries(req.headers));
-            if (!headers.success || !req.body) {
-                return Response.json({ error: "Missing required headers" }, { status: 400 });
-            }
-            const queueName = headers.data["x-vqs-queue-name"];
-            const messageId = headers.data["x-vqs-message-id"];
-            const attempt = headers.data["x-vqs-message-attempt"];
-            if (!queueName.startsWith(prefix)) {
-                return Response.json({ error: "Unhandled queue" }, { status: 400 });
+        }
+    };
+}
+__name(createStorage, "createStorage");
+// ../world-local/dist/streamer.js
+var import_node_events = require("node:events");
+var import_node_path3 = __toESM(require("node:path"), 1);
+var monotonicUlid2 = monotonicFactory(() => Math.random());
+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 = serialized.subarray(1);
+    return { eof, chunk };
+}
+__name(deserializeChunk, "deserializeChunk");
+function createStreamer(basedir) {
+    const streamEmitter = new import_node_events.EventEmitter();
+    return {
+        async writeToStream(name, chunk) {
+            const chunkId = `strm_${monotonicUlid2()}`;
+            if (typeof chunk === "string") {
+                chunk = new TextEncoder().encode(chunk);
             }
-            const body = await new JsonTransport().deserialize(req.body);
-            try {
-                const response = await handler(body, { attempt, queueName, messageId });
-                const retryIn = typeof response === "undefined" ? null : response.timeoutSeconds;
-                if (retryIn) {
-                    return Response.json({ retryIn }, { status: 503 });
+            const serialized = serializeChunk({
+                chunk: Buffer.from(chunk),
+                eof: false
+            });
+            const chunkPath = import_node_path3.default.join(basedir, "streams", "chunks", `${name}-${chunkId}.json`);
+            await write(chunkPath, serialized);
+            const chunkData = typeof chunk === "string" ? new TextEncoder().encode(chunk) : chunk instanceof Buffer ? new Uint8Array(chunk) : chunk;
+            streamEmitter.emit(`chunk:${name}`, {
+                streamName: name,
+                chunkData,
+                chunkId
+            });
+        },
+        async closeStream(name) {
+            const chunkId = `strm_${monotonicUlid2()}`;
+            const chunkPath = import_node_path3.default.join(basedir, "streams", "chunks", `${name}-${chunkId}.json`);
+            await write(chunkPath, serializeChunk({ chunk: Buffer.from([]), eof: true }));
+            streamEmitter.emit(`close:${name}`, { streamName: name });
+        },
+        async readFromStream(name, startIndex = 0) {
+            const chunksDir = import_node_path3.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;
+                    const chunkListener = /* @__PURE__ */ __name((event) => {
+                        deliveredChunkIds.add(event.chunkId);
+                        if (isReadingFromDisk) {
+                            bufferedEventChunks.push({
+                                chunkId: event.chunkId,
+                                chunkData: event.chunkData
+                            });
+                        }
+                        else {
+                            controller.enqueue(event.chunkData);
+                        }
+                    }, "chunkListener");
+                    const closeListener = /* @__PURE__ */ __name(() => {
+                        streamEmitter.off(`chunk:${name}`, chunkListener);
+                        streamEmitter.off(`close:${name}`, closeListener);
+                        controller.close();
+                    }, "closeListener");
+                    removeListeners = closeListener;
+                    streamEmitter.on(`chunk:${name}`, chunkListener);
+                    streamEmitter.on(`close:${name}`, closeListener);
+                    const files = await listJSONFiles(chunksDir);
+                    const chunkFiles = files.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 chunk = deserializeChunk(await readBuffer(import_node_path3.default.join(chunksDir, `${file2}.json`)));
+                        if (chunk?.eof === true) {
+                            isComplete = true;
+                            break;
+                        }
+                        if (chunk.chunk.byteLength) {
+                            controller.enqueue(chunk.chunk);
+                        }
+                    }
+                    isReadingFromDisk = false;
+                    bufferedEventChunks.sort((a, b) => a.chunkId.localeCompare(b.chunkId));
+                    for (const buffered of bufferedEventChunks) {
+                        controller.enqueue(buffered.chunkData);
+                    }
+                    if (isComplete) {
+                        removeListeners();
+                        controller.close();
+                        return;
+                    }
+                },
+                cancel() {
+                    removeListeners();
                 }
-                return Response.json({ ok: true });
-            }
-            catch (error45) {
-                return Response.json(String(error45), { status: 500 });
-            }
-        };
-    }, "createQueueHandler");
-    const getDeploymentId = /* @__PURE__ */ __name(async () => {
-        return "dpl_embedded";
-    }, "getDeploymentId");
-    return { queue, createQueueHandler, getDeploymentId };
+            });
+        }
+    };
 }
-__name(createQueue, "createQueue");
-// ../world-local/dist/storage.js
-var import_node_path2 = __toESM(require("node:path"), 1);
-// ../world-local/dist/fs.js
-var import_node_fs = require("node:fs");
-var import_node_path = __toESM(require("node:path"), 1);
-var ulid3 = monotonicFactory(() => Math.random());
-var Ulid = external_exports.string().ulid();
-function ulidToDate(maybeUlid) {
-    const ulid4 = Ulid.safeParse(maybeUlid);
-    if (!ulid4.success) {
-        return null;
-    }
-    return new Date(decodeTime(ulid4.data));
+__name(createStreamer, "createStreamer");
+// ../world-local/dist/index.js
+function createEmbeddedWorld({ dataDir, port }) {
+    const dir = dataDir ?? config.value.dataDir;
+    const queuePort = port ?? config.value.port;
+    return {
+        ...createQueue(queuePort),
+        ...createStorage(dir),
+        ...createStreamer(dir)
+    };
 }
-__name(ulidToDate, "ulidToDate");
-async function ensureDir(dirPath) {
-    try {
-        await import_node_fs.promises.mkdir(dirPath, { recursive: true });
+__name(createEmbeddedWorld, "createEmbeddedWorld");
+// ../../node_modules/.pnpm/mixpart@0.0.5-alpha.1/node_modules/mixpart/dist/index.mjs
+var MultipartParseError = class extends Error {
+    static {
+        __name(this, "MultipartParseError");
     }
-    catch (_error) {
+    constructor(message) {
+        super(message);
+        this.name = "MultipartParseError";
     }
+};
+function createSearch(pattern) {
+    const needle = new TextEncoder().encode(pattern);
+    return (haystack, start2 = 0) => Buffer.prototype.indexOf.call(haystack, needle, start2);
 }
-__name(ensureDir, "ensureDir");
-async function writeJSON(filePath, data, opts) {
-    return write(filePath, JSON.stringify(data, null, 2), opts);
-}
-__name(writeJSON, "writeJSON");
-async function write(filePath, data, opts) {
-    if (!opts?.overwrite) {
-        try {
-            await import_node_fs.promises.access(filePath);
-            throw new WorkflowAPIError(`File ${filePath} already exists and 'overwrite' is false`, { status: 409 });
-        }
-        catch (error45) {
-            if (error45.code !== "ENOENT") {
-                throw error45;
+__name(createSearch, "createSearch");
+function createPartialTailSearch(pattern) {
+    const needle = new TextEncoder().encode(pattern);
+    const byteIndexes = {};
+    for (let i = 0; i < needle.length; ++i) {
+        const byte = needle[i];
+        if (byteIndexes[byte] === void 0)
+            byteIndexes[byte] = [];
+        byteIndexes[byte].push(i);
+    }
+    return function (haystack) {
+        const haystackEnd = haystack.length - 1;
+        if (haystack[haystackEnd] in byteIndexes) {
+            const indexes = byteIndexes[haystack[haystackEnd]];
+            for (let i = indexes.length - 1; i >= 0; --i) {
+                for (let j = indexes[i], k = haystackEnd; j >= 0 && haystack[k] === needle[j]; --j, --k) {
+                    if (j === 0)
+                        return k;
+                }
             }
         }
-    }
-    const tempPath = `${filePath}.tmp.${ulid3()}`;
-    try {
-        await ensureDir(import_node_path.default.dirname(filePath));
-        await import_node_fs.promises.writeFile(tempPath, data);
-        await import_node_fs.promises.rename(tempPath, filePath);
-    }
-    catch (error45) {
-        await import_node_fs.promises.unlink(tempPath).catch(() => {
-        });
-        throw error45;
-    }
+        return -1;
+    };
 }
-__name(write, "write");
-async function readJSON(filePath, decoder) {
-    try {
-        const content = await import_node_fs.promises.readFile(filePath, "utf-8");
-        return decoder.parse(JSON.parse(content));
-    }
-    catch (error45) {
-        if (error45.code === "ENOENT")
-            return null;
-        throw error45;
+__name(createPartialTailSearch, "createPartialTailSearch");
+function parseHeaders(headerBytes) {
+    const headerText = new TextDecoder("iso-8859-1").decode(headerBytes);
+    const lines = headerText.trim().split(/\r?\n/);
+    const headerInit = [];
+    for (const line of lines) {
+        const colonIndex = line.indexOf(":");
+        if (colonIndex > 0) {
+            const name = line.slice(0, colonIndex).trim();
+            const value = line.slice(colonIndex + 1).trim();
+            headerInit.push([name, value]);
+        }
     }
+    return new Headers(headerInit);
 }
-__name(readJSON, "readJSON");
-async function readBuffer(filePath) {
-    const content = await import_node_fs.promises.readFile(filePath);
-    return content;
-}
-__name(readBuffer, "readBuffer");
-async function deleteJSON(filePath) {
-    try {
-        await import_node_fs.promises.unlink(filePath);
-    }
-    catch (error45) {
-        if (error45.code !== "ENOENT")
-            throw error45;
+__name(parseHeaders, "parseHeaders");
+function extractBoundary(contentType) {
+    const boundaryMatch = contentType.match(/boundary=(?:"([^"]+)"|([^;]+))/i);
+    if (!boundaryMatch) {
+        throw new MultipartParseError("No boundary found in Content-Type header");
     }
+    return boundaryMatch[1] ?? boundaryMatch[2];
 }
-__name(deleteJSON, "deleteJSON");
-async function listJSONFiles(dirPath) {
-    try {
-        const files = await import_node_fs.promises.readdir(dirPath);
-        return files.filter((f) => f.endsWith(".json")).map((f) => f.replace(".json", ""));
+__name(extractBoundary, "extractBoundary");
+var AsyncMessageQueue = class {
+    static {
+        __name(this, "AsyncMessageQueue");
     }
-    catch (error45) {
-        if (error45.code === "ENOENT")
-            return [];
-        throw error45;
+    queue = [];
+    waiters = [];
+    finished = false;
+    cancelled = false;
+    error = null;
+    /**
+     * Producer: Enqueue a message for consumption
+     */
+    enqueue(message) {
+        if (this.finished || this.cancelled)
+            return;
+        if (this.waiters.length > 0) {
+            const waiter = this.waiters.shift();
+            waiter.resolve(message);
+        }
+        else {
+            this.queue.push(message);
+        }
     }
-}
-__name(listJSONFiles, "listJSONFiles");
-function parseCursor(cursor) {
-    if (!cursor)
-        return null;
-    const parts = cursor.split("|");
-    return {
-        timestamp: new Date(parts[0]),
-        id: parts[1] || null
-    };
-}
-__name(parseCursor, "parseCursor");
-function createCursor(timestamp, id) {
-    return id ? `${timestamp.toISOString()}|${id}` : timestamp.toISOString();
-}
-__name(createCursor, "createCursor");
-async function paginatedFileSystemQuery(config3) {
-    const { directory, schema, filePrefix, filter, sortOrder = "desc", limit = 20, cursor, getCreatedAt, getId } = config3;
-    const fileIds = await listJSONFiles(directory);
-    const relevantFileIds = filePrefix ? fileIds.filter((fileId) => fileId.startsWith(filePrefix)) : fileIds;
-    const parsedCursor = parseCursor(cursor);
-    let candidateFileIds = relevantFileIds;
-    if (parsedCursor) {
-        candidateFileIds = relevantFileIds.filter((fileId) => {
-            const filenameDate = getCreatedAt(`${fileId}.json`);
-            if (filenameDate) {
-                const cursorTime = parsedCursor.timestamp.getTime();
-                const fileTime = filenameDate.getTime();
-                if (parsedCursor.id) {
-                    return sortOrder === "desc" ? fileTime <= cursorTime : fileTime >= cursorTime;
-                }
-                else {
-                    return sortOrder === "desc" ? fileTime < cursorTime : fileTime > cursorTime;
-                }
+    /**
+     * Producer: Signal completion (with optional error)
+     */
+    finish(error45) {
+        if (this.finished)
+            return;
+        this.finished = true;
+        this.error = error45 || null;
+        while (this.waiters.length > 0) {
+            const waiter = this.waiters.shift();
+            if (error45) {
+                waiter.reject(error45);
             }
-            return false;
-        });
-    }
-    else {
-        candidateFileIds = relevantFileIds.filter((fileId) => {
-            return getCreatedAt(`${fileId}.json`) !== null;
-        });
-    }
-    const validItems = [];
-    for (const fileId of candidateFileIds) {
-        const filePath = import_node_path.default.join(directory, `${fileId}.json`);
-        const item = await readJSON(filePath, schema);
-        if (item) {
-            if (filter && !filter(item))
-                continue;
-            if (parsedCursor) {
-                const itemTime = item.createdAt.getTime();
-                const cursorTime = parsedCursor.timestamp.getTime();
-                if (sortOrder === "desc") {
-                    if (itemTime > cursorTime)
-                        continue;
-                    if (itemTime === cursorTime && parsedCursor.id && getId) {
-                        const itemId = getId(item);
-                        if (itemId >= parsedCursor.id)
-                            continue;
-                    }
-                }
-                else {
-                    if (itemTime < cursorTime)
-                        continue;
-                    if (itemTime === cursorTime && parsedCursor.id && getId) {
-                        const itemId = getId(item);
-                        if (itemId <= parsedCursor.id)
-                            continue;
-                    }
-                }
+            else {
+                waiter.resolve(null);
             }
-            validItems.push(item);
         }
     }
-    validItems.sort((a, b) => {
-        const aTime = a.createdAt.getTime();
-        const bTime = b.createdAt.getTime();
-        const timeComparison = sortOrder === "asc" ? aTime - bTime : bTime - aTime;
-        if (timeComparison === 0 && getId) {
-            const aId = getId(a);
-            const bId = getId(b);
-            return sortOrder === "asc" ? aId.localeCompare(bId) : bId.localeCompare(aId);
+    /**
+     * Consumer: Cancel the queue (stops accepting new messages and notifies waiters)
+     */
+    cancel() {
+        if (this.cancelled || this.finished)
+            return;
+        this.cancelled = true;
+        while (this.waiters.length > 0) {
+            const waiter = this.waiters.shift();
+            waiter.resolve(null);
         }
-        return timeComparison;
-    });
-    const hasMore = validItems.length > limit;
-    const items = hasMore ? validItems.slice(0, limit) : validItems;
-    const nextCursor = hasMore && items.length > 0 ? createCursor(items[items.length - 1].createdAt, getId?.(items[items.length - 1])) : null;
-    return {
-        data: items,
-        cursor: nextCursor,
-        hasMore
-    };
-}
-__name(paginatedFileSystemQuery, "paginatedFileSystemQuery");
-// ../world-local/dist/storage.js
-var monotonicUlid = monotonicFactory(() => Math.random());
-function filterRunData(run, resolveData) {
-    if (resolveData === "none") {
-        return {
-            ...run,
-            input: [],
-            output: void 0
-        };
     }
-    return run;
-}
-__name(filterRunData, "filterRunData");
-function filterStepData(step, resolveData) {
-    if (resolveData === "none") {
-        return {
-            ...step,
-            input: [],
-            output: void 0
-        };
+    /**
+     * Consumer: Dequeue next message (or null if finished/cancelled)
+     */
+    async dequeue() {
+        if (this.queue.length > 0) {
+            return this.queue.shift();
+        }
+        if (this.finished || this.cancelled) {
+            if (this.error)
+                throw this.error;
+            return null;
+        }
+        return new Promise((resolve, reject) => {
+            this.waiters.push({ resolve, reject });
+        });
     }
-    return step;
-}
-__name(filterStepData, "filterStepData");
-function filterEventData(event, resolveData) {
-    if (resolveData === "none") {
-        const { eventData: _eventData, ...rest } = event;
-        return rest;
+    /**
+     * Check if the queue is in a terminal state
+     */
+    get isTerminal() {
+        return this.finished || this.cancelled;
     }
-    return event;
-}
-__name(filterEventData, "filterEventData");
-function filterHookData(hook, resolveData) {
-    if (resolveData === "none") {
-        const { metadata: _metadata, ...rest } = hook;
-        return rest;
+};
+async function* parseMultipartStream2(response, options) {
+    if (!response.body) {
+        throw new MultipartParseError("Response body is null");
     }
-    return hook;
-}
-__name(filterHookData, "filterHookData");
-var getObjectCreatedAt = /* @__PURE__ */ __name((idPrefix) => (filename) => {
-    const replaceRegex = new RegExp(`^${idPrefix}_`, "g");
-    const dashIndex = filename.indexOf("-");
-    if (dashIndex === -1) {
-        const ulid5 = filename.replace(/\.json$/, "").replace(replaceRegex, "");
-        return ulidToDate(ulid5);
+    const contentType = response.headers.get("content-type");
+    if (!contentType) {
+        throw new MultipartParseError("Missing Content-Type header");
     }
-    if (idPrefix === "step") {
-        const runId = filename.substring(0, dashIndex);
-        const ulid5 = runId.replace(/^wrun_/, "");
-        return ulidToDate(ulid5);
+    const boundary = extractBoundary(contentType);
+    const parser = new StreamingMultipartParser(boundary, options);
+    yield* parser.parseStream(response.body);
+}
+__name(parseMultipartStream2, "parseMultipartStream");
+var StreamingMultipartParser = class {
+    static {
+        __name(this, "StreamingMultipartParser");
     }
-    const id = filename.substring(dashIndex + 1).replace(/\.json$/, "");
-    const ulid4 = id.replace(replaceRegex, "");
-    return ulidToDate(ulid4);
-}, "getObjectCreatedAt");
-function createStorage(basedir) {
-    return {
-        runs: {
-            async create(data) {
-                const runId = `wrun_${monotonicUlid()}`;
-                const now = /* @__PURE__ */ new Date();
-                const result = {
-                    runId,
-                    deploymentId: data.deploymentId,
-                    status: "pending",
-                    workflowName: data.workflowName,
-                    executionContext: data.executionContext,
-                    input: data.input || [],
-                    output: void 0,
-                    error: void 0,
-                    errorCode: void 0,
-                    startedAt: void 0,
-                    completedAt: void 0,
-                    createdAt: now,
-                    updatedAt: now
-                };
-                const runPath = import_node_path2.default.join(basedir, "runs", `${runId}.json`);
-                await writeJSON(runPath, result);
-                return result;
-            },
-            async get(id, params) {
-                const runPath = import_node_path2.default.join(basedir, "runs", `${id}.json`);
-                const run = await readJSON(runPath, WorkflowRunSchema);
-                if (!run) {
-                    throw new WorkflowRunNotFoundError(id);
-                }
-                const resolveData = params?.resolveData ?? DEFAULT_RESOLVE_DATA_OPTION;
-                return filterRunData(run, resolveData);
-            },
-            async update(id, data) {
-                const runPath = import_node_path2.default.join(basedir, "runs", `${id}.json`);
-                const run = await readJSON(runPath, WorkflowRunSchema);
-                if (!run) {
-                    throw new WorkflowRunNotFoundError(id);
-                }
-                const now = /* @__PURE__ */ new Date();
-                const updatedRun = {
-                    ...run,
-                    ...data,
-                    updatedAt: now
-                };
-                if (data.status === "running" && !updatedRun.startedAt) {
-                    updatedRun.startedAt = now;
-                }
-                if (data.status === "completed" || data.status === "failed" || data.status === "cancelled") {
-                    updatedRun.completedAt = now;
-                }
-                await writeJSON(runPath, updatedRun, { overwrite: true });
-                return updatedRun;
-            },
-            async list(params) {
-                const resolveData = params?.resolveData ?? DEFAULT_RESOLVE_DATA_OPTION;
-                const result = await paginatedFileSystemQuery({
-                    directory: import_node_path2.default.join(basedir, "runs"),
-                    schema: WorkflowRunSchema,
-                    filter: /* @__PURE__ */ __name((run) => {
-                        if (params?.workflowName && run.workflowName !== params.workflowName) {
-                            return false;
-                        }
-                        if (params?.status && run.status !== params.status) {
-                            return false;
-                        }
-                        return true;
-                    }, "filter"),
-                    sortOrder: params?.pagination?.sortOrder ?? "desc",
-                    limit: params?.pagination?.limit,
-                    cursor: params?.pagination?.cursor,
-                    getCreatedAt: getObjectCreatedAt("wrun"),
-                    getId: /* @__PURE__ */ __name((run) => run.runId, "getId")
-                });
-                if (resolveData === "none") {
-                    return {
-                        ...result,
-                        data: result.data.map((run) => ({
-                            ...run,
-                            input: [],
-                            output: void 0
-                        }))
-                    };
-                }
-                return result;
-            },
-            async cancel(id, params) {
-                const run = await this.update(id, { status: "cancelled" });
-                const resolveData = params?.resolveData ?? DEFAULT_RESOLVE_DATA_OPTION;
-                return filterRunData(run, resolveData);
-            },
-            async pause(id, params) {
-                const run = await this.update(id, { status: "paused" });
-                const resolveData = params?.resolveData ?? DEFAULT_RESOLVE_DATA_OPTION;
-                return filterRunData(run, resolveData);
-            },
-            async resume(id, params) {
-                const run = await this.update(id, { status: "running" });
-                const resolveData = params?.resolveData ?? DEFAULT_RESOLVE_DATA_OPTION;
-                return filterRunData(run, resolveData);
+    boundary;
+    findOpeningBoundary;
+    openingBoundaryLength;
+    findBoundary;
+    findPartialTailBoundary;
+    boundaryLength;
+    findDoubleNewline;
+    // Safety limits
+    maxHeaderSize;
+    maxBoundaryBuffer;
+    state = 0;
+    buffer = null;
+    currentHeaders = new Headers();
+    currentPayloadController = null;
+    constructor(boundary, options = {}) {
+        this.boundary = boundary;
+        this.findOpeningBoundary = createSearch(`--${boundary}`);
+        this.openingBoundaryLength = 2 + boundary.length;
+        this.findBoundary = createSearch(`\r
+--${boundary}`);
+        this.findPartialTailBoundary = createPartialTailSearch(`\r
+--${boundary}`);
+        this.boundaryLength = 4 + boundary.length;
+        this.findDoubleNewline = createSearch("\r\n\r\n");
+        this.maxHeaderSize = options.maxHeaderSize ?? 65536;
+        this.maxBoundaryBuffer = options.maxBoundaryBuffer ?? 8192;
+    }
+    async *parseStream(stream) {
+        const reader = stream.getReader();
+        const messageQueue = new AsyncMessageQueue();
+        const producer = this.startProducer(reader, messageQueue);
+        try {
+            yield* this.consumeMessages(messageQueue);
+        }
+        finally {
+            messageQueue.cancel();
+            this.closeCurrentPayload();
+            try {
+                await reader.cancel();
             }
-        },
-        steps: {
-            async create(runId, data) {
-                const now = /* @__PURE__ */ new Date();
-                const result = {
-                    runId,
-                    stepId: data.stepId,
-                    stepName: data.stepName,
-                    status: "pending",
-                    input: data.input,
-                    output: void 0,
-                    error: void 0,
-                    errorCode: void 0,
-                    attempt: 0,
-                    startedAt: void 0,
-                    completedAt: void 0,
-                    createdAt: now,
-                    updatedAt: now
-                };
-                const compositeKey = `${runId}-${data.stepId}`;
-                const stepPath = import_node_path2.default.join(basedir, "steps", `${compositeKey}.json`);
-                await writeJSON(stepPath, result);
-                return result;
-            },
-            async get(runId, stepId, params) {
-                if (!runId) {
-                    const fileIds = await listJSONFiles(import_node_path2.default.join(basedir, "steps"));
-                    const fileId = fileIds.find((fileId2) => fileId2.endsWith(`-${stepId}`));
-                    if (!fileId) {
-                        throw new Error(`Step ${stepId} not found`);
-                    }
-                    runId = fileId.split("-")[0];
-                }
-                const compositeKey = `${runId}-${stepId}`;
-                const stepPath = import_node_path2.default.join(basedir, "steps", `${compositeKey}.json`);
-                const step = await readJSON(stepPath, StepSchema);
-                if (!step) {
-                    throw new Error(`Step ${stepId} in run ${runId} not found`);
-                }
-                const resolveData = params?.resolveData ?? DEFAULT_RESOLVE_DATA_OPTION;
-                return filterStepData(step, resolveData);
-            },
-            async update(runId, stepId, data) {
-                const compositeKey = `${runId}-${stepId}`;
-                const stepPath = import_node_path2.default.join(basedir, "steps", `${compositeKey}.json`);
-                const step = await readJSON(stepPath, StepSchema);
-                if (!step) {
-                    throw new Error(`Step ${stepId} in run ${runId} not found`);
-                }
-                const now = /* @__PURE__ */ new Date();
-                const updatedStep = {
-                    ...step,
-                    ...data,
-                    updatedAt: now
-                };
-                if (data.status === "running" && !updatedStep.startedAt) {
-                    updatedStep.startedAt = now;
-                }
-                if (data.status === "completed" || data.status === "failed") {
-                    updatedStep.completedAt = now;
-                }
-                await writeJSON(stepPath, updatedStep, { overwrite: true });
-                return updatedStep;
-            },
-            async list(params) {
-                const resolveData = params.resolveData ?? DEFAULT_RESOLVE_DATA_OPTION;
-                const result = await paginatedFileSystemQuery({
-                    directory: import_node_path2.default.join(basedir, "steps"),
-                    schema: StepSchema,
-                    filePrefix: `${params.runId}-`,
-                    sortOrder: params.pagination?.sortOrder ?? "desc",
-                    limit: params.pagination?.limit,
-                    cursor: params.pagination?.cursor,
-                    getCreatedAt: getObjectCreatedAt("step"),
-                    getId: /* @__PURE__ */ __name((step) => step.stepId, "getId")
-                });
-                if (resolveData === "none") {
-                    return {
-                        ...result,
-                        data: result.data.map((step) => ({
-                            ...step,
-                            input: [],
-                            output: void 0
-                        }))
-                    };
-                }
-                return result;
+            catch (error45) {
             }
-        },
-        // Events - filesystem-backed storage
-        events: {
-            async create(runId, data, params) {
-                const eventId = `evnt_${monotonicUlid()}`;
-                const now = /* @__PURE__ */ new Date();
-                const result = {
-                    ...data,
-                    runId,
-                    eventId,
-                    createdAt: now
-                };
-                const compositeKey = `${runId}-${eventId}`;
-                const eventPath = import_node_path2.default.join(basedir, "events", `${compositeKey}.json`);
-                await writeJSON(eventPath, result);
-                const resolveData = params?.resolveData ?? DEFAULT_RESOLVE_DATA_OPTION;
-                return filterEventData(result, resolveData);
-            },
-            async list(params) {
-                const { runId } = params;
-                const resolveData = params.resolveData ?? DEFAULT_RESOLVE_DATA_OPTION;
-                const result = await paginatedFileSystemQuery({
-                    directory: import_node_path2.default.join(basedir, "events"),
-                    schema: EventSchema,
-                    filePrefix: `${runId}-`,
-                    // Events in chronological order (oldest first) by default,
-                    // different from the default for other list calls.
-                    sortOrder: params.pagination?.sortOrder ?? "asc",
-                    limit: params.pagination?.limit,
-                    cursor: params.pagination?.cursor,
-                    getCreatedAt: getObjectCreatedAt("evnt"),
-                    getId: /* @__PURE__ */ __name((event) => event.eventId, "getId")
-                });
-                if (resolveData === "none") {
-                    return {
-                        ...result,
-                        data: result.data.map((event) => {
-                            const { eventData: _eventData, ...rest } = event;
-                            return rest;
-                        })
-                    };
-                }
-                return result;
-            },
-            async listByCorrelationId(params) {
-                const correlationId = params.correlationId;
-                const resolveData = params.resolveData ?? DEFAULT_RESOLVE_DATA_OPTION;
-                const result = await paginatedFileSystemQuery({
-                    directory: import_node_path2.default.join(basedir, "events"),
-                    schema: EventSchema,
-                    // No filePrefix - search all events
-                    filter: /* @__PURE__ */ __name((event) => event.correlationId === correlationId, "filter"),
-                    // Events in chronological order (oldest first) by default,
-                    // different from the default for other list calls.
-                    sortOrder: params.pagination?.sortOrder ?? "asc",
-                    limit: params.pagination?.limit,
-                    cursor: params.pagination?.cursor,
-                    getCreatedAt: getObjectCreatedAt("evnt"),
-                    getId: /* @__PURE__ */ __name((event) => event.eventId, "getId")
-                });
-                if (resolveData === "none") {
-                    return {
-                        ...result,
-                        data: result.data.map((event) => {
-                            const { eventData: _eventData, ...rest } = event;
-                            return rest;
-                        })
-                    };
+            await producer;
+        }
+    }
+    /**
+     * Producer: Continuously read chunks and parse messages
+     */
+    async startProducer(reader, messageQueue) {
+        try {
+            while (!messageQueue.isTerminal) {
+                let result;
+                try {
+                    result = await reader.read();
                 }
-                return result;
-            }
-        },
-        // Hooks
-        hooks: {
-            async create(runId, data) {
-                const now = /* @__PURE__ */ new Date();
-                const result = {
-                    runId,
-                    hookId: data.hookId,
-                    token: data.token,
-                    metadata: data.metadata,
-                    ownerId: "embedded-owner",
-                    projectId: "embedded-project",
-                    environment: "embedded",
-                    createdAt: now
-                };
-                const hookPath = import_node_path2.default.join(basedir, "hooks", `${data.hookId}.json`);
-                await writeJSON(hookPath, result);
-                return result;
-            },
-            async get(hookId, params) {
-                const hookPath = import_node_path2.default.join(basedir, "hooks", `${hookId}.json`);
-                const hook = await readJSON(hookPath, HookSchema);
-                if (!hook) {
-                    throw new Error(`Hook ${hookId} not found`);
+                catch (readError) {
+                    if (readError instanceof Error && (readError.name === "AbortError" || readError.constructor.name === "AbortError" || readError.name === "TimeoutError" || readError.constructor.name === "TimeoutError")) {
+                        break;
+                    }
+                    throw readError;
                 }
-                const resolveData = params?.resolveData || DEFAULT_RESOLVE_DATA_OPTION;
-                return filterHookData(hook, resolveData);
-            },
-            async getByToken(token) {
-                const hooksDir = import_node_path2.default.join(basedir, "hooks");
-                const files = await listJSONFiles(hooksDir);
-                for (const file2 of files) {
-                    const hookPath = import_node_path2.default.join(hooksDir, `${file2}.json`);
-                    const hook = await readJSON(hookPath, HookSchema);
-                    if (hook && hook.token === token) {
-                        return hook;
+                const { done, value } = result;
+                if (done) {
+                    if (this.buffer !== null && this.buffer.length > 0) {
+                        const messages2 = this.write(new Uint8Array(0));
+                        for (const message of messages2) {
+                            if (messageQueue.isTerminal)
+                                break;
+                            messageQueue.enqueue(message);
+                        }
                     }
-                }
-                throw new Error(`Hook with token ${token} not found`);
-            },
-            async list(params) {
-                const hooksDir = import_node_path2.default.join(basedir, "hooks");
-                const resolveData = params.resolveData || DEFAULT_RESOLVE_DATA_OPTION;
-                const result = await paginatedFileSystemQuery({
-                    directory: hooksDir,
-                    schema: HookSchema,
-                    sortOrder: params.pagination?.sortOrder,
-                    limit: params.pagination?.limit,
-                    cursor: params.pagination?.cursor,
-                    filePrefix: void 0,
-                    // Hooks don't have ULIDs, so we can't optimize by filename
-                    filter: /* @__PURE__ */ __name((hook) => {
-                        if (params.runId && hook.runId !== params.runId) {
-                            return false;
+                    if (this.state !== 4) {
+                        if (this.state === 0) {
+                            throw new MultipartParseError("Invalid multipart stream: missing initial boundary");
                         }
-                        return true;
-                    }, "filter"),
-                    getCreatedAt: /* @__PURE__ */ __name(() => {
-                        return /* @__PURE__ */ new Date(0);
-                    }, "getCreatedAt"),
-                    getId: /* @__PURE__ */ __name((hook) => hook.hookId, "getId")
-                });
-                return {
-                    ...result,
-                    data: result.data.map((hook) => filterHookData(hook, resolveData))
-                };
-            },
-            async dispose(hookId) {
-                const hookPath = import_node_path2.default.join(basedir, "hooks", `${hookId}.json`);
-                const hook = await readJSON(hookPath, HookSchema);
-                if (!hook) {
-                    throw new Error(`Hook ${hookId} not found`);
+                        throw new MultipartParseError("Unexpected end of stream");
+                    }
+                    break;
+                }
+                if (!(value instanceof Uint8Array)) {
+                    throw new MultipartParseError(`Invalid chunk type: expected Uint8Array, got ${typeof value}`);
+                }
+                const messages = this.write(value);
+                for (const message of messages) {
+                    if (messageQueue.isTerminal)
+                        break;
+                    messageQueue.enqueue(message);
                 }
-                await deleteJSON(hookPath);
-                return hook;
+            }
+            if (!messageQueue.isTerminal) {
+                messageQueue.finish();
             }
         }
-    };
-}
-__name(createStorage, "createStorage");
-// ../world-local/dist/streamer.js
-var import_node_events = require("node:events");
-var import_node_path3 = __toESM(require("node:path"), 1);
-var monotonicUlid2 = monotonicFactory(() => Math.random());
-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 = serialized.subarray(1);
-    return { eof, chunk };
-}
-__name(deserializeChunk, "deserializeChunk");
-function createStreamer(basedir) {
-    const streamEmitter = new import_node_events.EventEmitter();
-    return {
-        async writeToStream(name, chunk) {
-            const chunkId = `strm_${monotonicUlid2()}`;
-            if (typeof chunk === "string") {
-                chunk = new TextEncoder().encode(chunk);
+        catch (error45) {
+            this.closeCurrentPayload(error45);
+            if (!messageQueue.isTerminal) {
+                messageQueue.finish(error45);
             }
-            const serialized = serializeChunk({
-                chunk: Buffer.from(chunk),
-                eof: false
-            });
-            const chunkPath = import_node_path3.default.join(basedir, "streams", "chunks", `${name}-${chunkId}.json`);
-            await write(chunkPath, serialized);
-            const chunkData = typeof chunk === "string" ? new TextEncoder().encode(chunk) : chunk instanceof Buffer ? new Uint8Array(chunk) : chunk;
-            streamEmitter.emit(`chunk:${name}`, {
-                streamName: name,
-                chunkData,
-                chunkId
-            });
-        },
-        async closeStream(name) {
-            const chunkId = `strm_${monotonicUlid2()}`;
-            const chunkPath = import_node_path3.default.join(basedir, "streams", "chunks", `${name}-${chunkId}.json`);
-            await write(chunkPath, serializeChunk({ chunk: Buffer.from([]), eof: true }));
-            streamEmitter.emit(`close:${name}`, { streamName: name });
-        },
-        async readFromStream(name, startIndex = 0) {
-            const chunksDir = import_node_path3.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;
-                    const chunkListener = /* @__PURE__ */ __name((event) => {
-                        deliveredChunkIds.add(event.chunkId);
-                        if (isReadingFromDisk) {
-                            bufferedEventChunks.push({
-                                chunkId: event.chunkId,
-                                chunkData: event.chunkData
-                            });
-                        }
-                        else {
-                            controller.enqueue(event.chunkData);
-                        }
-                    }, "chunkListener");
-                    const closeListener = /* @__PURE__ */ __name(() => {
-                        streamEmitter.off(`chunk:${name}`, chunkListener);
-                        streamEmitter.off(`close:${name}`, closeListener);
-                        controller.close();
-                    }, "closeListener");
-                    removeListeners = closeListener;
-                    streamEmitter.on(`chunk:${name}`, chunkListener);
-                    streamEmitter.on(`close:${name}`, closeListener);
-                    const files = await listJSONFiles(chunksDir);
-                    const chunkFiles = files.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 chunk = deserializeChunk(await readBuffer(import_node_path3.default.join(chunksDir, `${file2}.json`)));
-                        if (chunk?.eof === true) {
-                            isComplete = true;
-                            break;
-                        }
-                        if (chunk.chunk.byteLength) {
-                            controller.enqueue(chunk.chunk);
+        }
+        finally {
+            try {
+                reader.releaseLock();
+            }
+            catch (error45) {
+            }
+        }
+    }
+    /**
+     * Consumer: Yield messages from the queue
+     */
+    async *consumeMessages(messageQueue) {
+        while (true) {
+            const message = await messageQueue.dequeue();
+            if (message === null) {
+                break;
+            }
+            yield message;
+        }
+    }
+    /**
+     * Process a chunk of data through the state machine and return any complete messages.
+     *
+     * Returns an array because a single chunk can contain multiple complete messages
+     * when small messages with headers + body + boundary all fit in one network chunk.
+     * All messages must be captured and queued to maintain proper message ordering.
+     */
+    write(chunk) {
+        const newMessages = [];
+        if (this.state === 4) {
+            throw new MultipartParseError("Unexpected data after end of stream");
+        }
+        let index = 0;
+        let chunkLength = chunk.length;
+        if (this.buffer !== null) {
+            const newSize = this.buffer.length + chunkLength;
+            const maxAllowedSize = this.state === 2 ? this.maxHeaderSize : this.maxBoundaryBuffer;
+            if (newSize > maxAllowedSize) {
+                throw new MultipartParseError(`Buffer size limit exceeded: ${newSize} bytes > ${maxAllowedSize} bytes. This may indicate malformed multipart data with ${this.state === 2 ? "oversized headers" : "invalid boundaries"}.`);
+            }
+            const newChunk = new Uint8Array(newSize);
+            newChunk.set(this.buffer, 0);
+            newChunk.set(chunk, this.buffer.length);
+            chunk = newChunk;
+            chunkLength = chunk.length;
+            this.buffer = null;
+        }
+        if (chunkLength === 0 && this.state === 0) {
+            throw new MultipartParseError("Invalid multipart stream: missing initial boundary");
+        }
+        while (true) {
+            if (this.state === 3) {
+                if (chunkLength - index < this.boundaryLength) {
+                    const remainingData = chunk.subarray(index);
+                    if (remainingData.length > this.maxBoundaryBuffer) {
+                        throw new MultipartParseError(`Boundary buffer limit exceeded: ${remainingData.length} > ${this.maxBoundaryBuffer}`);
+                    }
+                    this.buffer = remainingData;
+                    break;
+                }
+                const boundaryIndex = this.findBoundary(chunk, index);
+                if (boundaryIndex === -1) {
+                    const partialTailIndex = this.findPartialTailBoundary(chunk);
+                    if (partialTailIndex === -1) {
+                        this.writeBody(index === 0 ? chunk : chunk.subarray(index));
+                    }
+                    else {
+                        this.writeBody(chunk.subarray(index, partialTailIndex));
+                        const partialBoundary = chunk.subarray(partialTailIndex);
+                        if (partialBoundary.length > this.maxBoundaryBuffer) {
+                            throw new MultipartParseError(`Partial boundary too large: ${partialBoundary.length} > ${this.maxBoundaryBuffer}`);
                         }
+                        this.buffer = partialBoundary;
+                    }
+                    break;
+                }
+                this.writeBody(chunk.subarray(index, boundaryIndex));
+                this.finishMessage();
+                index = boundaryIndex + this.boundaryLength;
+                this.state = 1;
+            }
+            if (this.state === 1) {
+                if (chunkLength - index < 2) {
+                    const remainingData = chunk.subarray(index);
+                    if (remainingData.length > this.maxBoundaryBuffer) {
+                        throw new MultipartParseError(`After-boundary buffer limit exceeded: ${remainingData.length} > ${this.maxBoundaryBuffer}`);
+                    }
+                    this.buffer = remainingData;
+                    break;
+                }
+                if (chunk[index] === 45 && chunk[index + 1] === 45) {
+                    this.state = 4;
+                    break;
+                }
+                if (chunk[index] === 13 && chunk[index + 1] === 10) {
+                    index += 2;
+                }
+                else if (chunk[index] === 10) {
+                    index += 1;
+                }
+                else {
+                    throw new MultipartParseError(`Invalid character after boundary: expected CRLF or LF, got 0x${chunk[index].toString(16)}`);
+                }
+                this.state = 2;
+            }
+            if (this.state === 2) {
+                if (chunkLength - index < 4) {
+                    const remainingData = chunk.subarray(index);
+                    if (remainingData.length > this.maxHeaderSize) {
+                        throw new MultipartParseError(`Header buffer limit exceeded: ${remainingData.length} > ${this.maxHeaderSize}`);
                     }
-                    isReadingFromDisk = false;
-                    bufferedEventChunks.sort((a, b) => a.chunkId.localeCompare(b.chunkId));
-                    for (const buffered of bufferedEventChunks) {
-                        controller.enqueue(buffered.chunkData);
+                    this.buffer = remainingData;
+                    break;
+                }
+                let headerEndIndex = this.findDoubleNewline(chunk, index);
+                let headerEndOffset = 4;
+                if (headerEndIndex === -1) {
+                    const lfDoubleNewline = createSearch("\n\n");
+                    headerEndIndex = lfDoubleNewline(chunk, index);
+                    headerEndOffset = 2;
+                }
+                if (headerEndIndex === -1) {
+                    const headerData = chunk.subarray(index);
+                    if (headerData.length > this.maxHeaderSize) {
+                        throw new MultipartParseError(`Headers too large: ${headerData.length} > ${this.maxHeaderSize} bytes`);
                     }
-                    if (isComplete) {
-                        removeListeners();
-                        controller.close();
-                        return;
+                    this.buffer = headerData;
+                    break;
+                }
+                const headerBytes = chunk.subarray(index, headerEndIndex);
+                this.currentHeaders = parseHeaders(headerBytes);
+                const message = this.createStreamingMessage();
+                newMessages.push(message);
+                index = headerEndIndex + headerEndOffset;
+                this.state = 3;
+                continue;
+            }
+            if (this.state === 0) {
+                if (chunkLength < this.openingBoundaryLength) {
+                    if (chunk.length > this.maxBoundaryBuffer) {
+                        throw new MultipartParseError(`Initial chunk too large for boundary detection: ${chunk.length} > ${this.maxBoundaryBuffer}`);
                     }
-                },
-                cancel() {
-                    removeListeners();
+                    this.buffer = chunk;
+                    break;
                 }
-            });
+                const boundaryIndex = this.findOpeningBoundary(chunk);
+                if (boundaryIndex !== 0) {
+                    throw new MultipartParseError("Invalid multipart stream: missing initial boundary");
+                }
+                index = this.openingBoundaryLength;
+                this.state = 1;
+            }
         }
-    };
-}
-__name(createStreamer, "createStreamer");
-// ../world-local/dist/index.js
-function createEmbeddedWorld({ dataDir, port }) {
-    const dir = dataDir ?? config.value.dataDir;
-    const queuePort = port ?? config.value.port;
-    return {
-        ...createQueue(queuePort),
-        ...createStorage(dir),
-        ...createStreamer(dir)
-    };
-}
-__name(createEmbeddedWorld, "createEmbeddedWorld");
-// ../../node_modules/.pnpm/@vercel+queue@0.0.0-alpha.24/node_modules/@vercel/queue/dist/index.mjs
+        return newMessages;
+    }
+    createStreamingMessage() {
+        const headers = new Headers(this.currentHeaders);
+        const payload = new ReadableStream({
+            start: /* @__PURE__ */ __name((controller) => {
+                this.currentPayloadController = controller;
+            }, "start")
+        });
+        this.currentHeaders = new Headers();
+        return {
+            headers,
+            payload
+        };
+    }
+    writeBody(chunk) {
+        if (this.currentPayloadController) {
+            this.currentPayloadController.enqueue(chunk);
+        }
+    }
+    finishMessage() {
+        if (this.currentPayloadController) {
+            this.currentPayloadController.close();
+            this.currentPayloadController = null;
+        }
+    }
+    /**
+     * Close current payload controller if open (used during cleanup)
+     * If an error is provided, forwards it to the payload consumer
+     */
+    closeCurrentPayload(error45) {
+        if (this.currentPayloadController) {
+            try {
+                if (error45) {
+                    this.currentPayloadController.error(error45);
+                }
+                else {
+                    this.currentPayloadController.close();
+                }
+            }
+            catch (controllerError) {
+            }
+            this.currentPayloadController = null;
+        }
+    }
+};
+// ../../node_modules/.pnpm/@vercel+queue@0.0.0-alpha.28/node_modules/@vercel/queue/dist/index.mjs
 var import_oidc = __toESM(require_dist(), 1);
 async function streamToBuffer2(stream) {
     let totalLength = 0;
@@ -19815,15 +19879,22 @@ var QueueClient = class {
     }
     baseUrl;
     basePath;
+    customHeaders = {};
     token;
     /**
      * Create a new Vercel Queue Service client
      * @param options Client configuration options
      */
     constructor(options = {}) {
-        this.baseUrl = options.baseUrl || "https://vercel-queue.com";
-        this.basePath = options.basePath || "/api/v2/messages";
-        this.token = options.token;
+        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/v2/messages";
+        this.token = options.token || process.env.VERCEL_QUEUE_TOKEN;
+        const VERCEL_QUEUE_HEADER_PREFIX = "VERCEL_QUEUE_HEADER_";
+        this.customHeaders = Object.fromEntries(Object.entries(process.env).filter(([key]) => key.startsWith(VERCEL_QUEUE_HEADER_PREFIX)).map(([key, value]) => [
+            // This allows headers to use dashes independent of shell used
+            key.replace(VERCEL_QUEUE_HEADER_PREFIX, "").replaceAll("__", "-"),
+            value || ""
+        ]));
     }
     async getToken() {
         if (this.token) {
@@ -19850,7 +19921,8 @@ var QueueClient = class {
         const headers = new Headers({
             Authorization: `Bearer ${await this.getToken()}`,
             "Vqs-Queue-Name": queueName,
-            "Content-Type": transport.contentType
+            "Content-Type": transport.contentType,
+            ...this.customHeaders
         });
         const deploymentId = options.deploymentId || process.env.VERCEL_DEPLOYMENT_ID;
         if (deploymentId) {
@@ -19865,8 +19937,8 @@ var QueueClient = class {
         const body = transport.serialize(payload);
         const response = await fetch(`${this.baseUrl}${this.basePath}`, {
             method: "POST",
-            headers,
-            body
+            body,
+            headers
         });
         if (!response.ok) {
             if (response.status === 400) {
@@ -19912,7 +19984,8 @@ var QueueClient = class {
             Authorization: `Bearer ${await this.getToken()}`,
             "Vqs-Queue-Name": queueName,
             "Vqs-Consumer-Group": consumerGroup,
-            Accept: "multipart/mixed"
+            Accept: "multipart/mixed",
+            ...this.customHeaders
         });
         if (visibilityTimeoutSeconds !== void 0) {
             headers.set("Vqs-Visibility-Timeout", visibilityTimeoutSeconds.toString());
@@ -19952,7 +20025,7 @@ var QueueClient = class {
             }
             throw new Error(`Failed to receive messages: ${response.status} ${response.statusText}`);
         }
-        for await (const multipartMessage of parseMultipartStream(response)) {
+        for await (const multipartMessage of parseMultipartStream2(response)) {
             try {
                 const parsedHeaders = parseQueueHeaders(multipartMessage.headers);
                 if (!parsedHeaders) {
@@ -19979,7 +20052,8 @@ var QueueClient = class {
             Authorization: `Bearer ${await this.getToken()}`,
             "Vqs-Queue-Name": queueName,
             "Vqs-Consumer-Group": consumerGroup,
-            Accept: "multipart/mixed"
+            Accept: "multipart/mixed",
+            ...this.customHeaders
         });
         if (visibilityTimeoutSeconds !== void 0) {
             headers.set("Vqs-Visibility-Timeout", visibilityTimeoutSeconds.toString());
@@ -20037,7 +20111,7 @@ var QueueClient = class {
             throw new Error("Transport is required when skipPayload is not true");
         }
         try {
-            for await (const multipartMessage of parseMultipartStream(response)) {
+            for await (const multipartMessage of parseMultipartStream2(response)) {
                 try {
                     const parsedHeaders = parseQueueHeaders(multipartMessage.headers);
                     if (!parsedHeaders) {
@@ -20086,7 +20160,8 @@ var QueueClient = class {
                 Authorization: `Bearer ${await this.getToken()}`,
                 "Vqs-Queue-Name": queueName,
                 "Vqs-Consumer-Group": consumerGroup,
-                "Vqs-Ticket": ticket
+                "Vqs-Ticket": ticket,
+                ...this.customHeaders
             })
         });
         if (!response.ok) {
@@ -20132,7 +20207,8 @@ var QueueClient = class {
                 "Vqs-Queue-Name": queueName,
                 "Vqs-Consumer-Group": consumerGroup,
                 "Vqs-Ticket": ticket,
-                "Vqs-Visibility-Timeout": visibilityTimeoutSeconds.toString()
+                "Vqs-Visibility-Timeout": visibilityTimeoutSeconds.toString(),
+                ...this.customHeaders
             })
         });
         if (!response.ok) {
@@ -20277,7 +20353,6 @@ function handleCallback(handlers) {
 __name(handleCallback, "handleCallback");
 var devRouteHandlers2 = /* @__PURE__ */ new Map();
 var wildcardRouteHandlers2 = /* @__PURE__ */ new Map();
-var routeHandlerKeys = /* @__PURE__ */ new WeakMap();
 function cleanupDeadRefs(key, refs) {
     const aliveRefs = refs.filter((ref) => ref.deref() !== void 0);
     if (aliveRefs.length === 0) {
@@ -20293,45 +20368,14 @@ function isDevMode() {
 }
 __name(isDevMode, "isDevMode");
 function registerDevRouteHandler(routeHandler, handlers) {
-    const existingKeys = routeHandlerKeys.get(routeHandler);
-    if (existingKeys) {
-        const newKeys = /* @__PURE__ */ new Set();
-        for (const topicName in handlers) {
-            for (const consumerGroup in handlers[topicName]) {
-                newKeys.add(`${topicName}:${consumerGroup}`);
-            }
-        }
-        for (const key of existingKeys) {
-            if (!newKeys.has(key)) {
-                const [topicPattern] = key.split(":");
-                if (topicPattern.includes("*")) {
-                    const refs = wildcardRouteHandlers2.get(key);
-                    if (refs) {
-                        const filteredRefs = refs.filter((ref) => ref.deref() !== routeHandler);
-                        if (filteredRefs.length === 0) {
-                            wildcardRouteHandlers2.delete(key);
-                        }
-                        else {
-                            wildcardRouteHandlers2.set(key, filteredRefs);
-                        }
-                    }
-                }
-                else {
-                    devRouteHandlers2.delete(key);
-                }
-            }
-        }
-    }
-    const keys = /* @__PURE__ */ new Set();
     for (const topicName in handlers) {
         for (const consumerGroup in handlers[topicName]) {
             const key = `${topicName}:${consumerGroup}`;
-            keys.add(key);
             if (topicName.includes("*")) {
-                const weakRef = new WeakRef(routeHandler);
                 const existing = wildcardRouteHandlers2.get(key) || [];
                 cleanupDeadRefs(key, existing);
                 const cleanedRefs = wildcardRouteHandlers2.get(key) || [];
+                const weakRef = new WeakRef(routeHandler);
                 cleanedRefs.push(weakRef);
                 wildcardRouteHandlers2.set(key, cleanedRefs);
             }
@@ -20343,7 +20387,6 @@ function registerDevRouteHandler(routeHandler, handlers) {
             }
         }
     }
-    routeHandlerKeys.set(routeHandler, keys);
 }
 __name(registerDevRouteHandler, "registerDevRouteHandler");
 function findRouteHandlersForTopic(topicName) {
@@ -20733,45 +20776,6 @@ async function send(topicName, payload, options) {
     return { messageId: result.messageId };
 }
 __name(send, "send");
-// ../world-vercel/dist/queue.js
-var MessageWrapper = object({
-    payload: QueuePayloadSchema,
-    queueName: ValidQueueName
-});
-function createQueue2() {
-    const queue = /* @__PURE__ */ __name(async (queueName, x, opts) => {
-        const encoded = MessageWrapper.encode({
-            payload: x,
-            queueName
-        });
-        const sanitizedQueueName = queueName.replace(/[^A-Za-z0-9-_]/g, "-");
-        const { messageId } = await send(sanitizedQueueName, encoded, opts);
-        return { messageId: MessageId.parse(messageId) };
-    }, "queue");
-    const createQueueHandler = /* @__PURE__ */ __name((prefix, handler) => {
-        return handleCallback({
-            [`${prefix}*`]: {
-                default: /* @__PURE__ */ __name((body, meta) => {
-                    const { payload, queueName } = MessageWrapper.parse(body);
-                    return handler(payload, {
-                        queueName,
-                        messageId: MessageId.parse(meta.messageId),
-                        attempt: meta.deliveryCount
-                    });
-                }, "default")
-            }
-        });
-    }, "createQueueHandler");
-    const getDeploymentId = /* @__PURE__ */ __name(async () => {
-        const deploymentId = process.env.VERCEL_DEPLOYMENT_ID;
-        if (!deploymentId) {
-            throw new Error("VERCEL_DEPLOYMENT_ID environment variable is not set");
-        }
-        return deploymentId;
-    }, "getDeploymentId");
-    return { queue, createQueueHandler, getDeploymentId };
-}
-__name(createQueue2, "createQueue");
 // ../world-vercel/dist/utils.js
 var import_oidc2 = __toESM(require_dist(), 1);
 var DEFAULT_RESOLVE_DATA_OPTION2 = "all";
@@ -20782,7 +20786,15 @@ function dateToStringReplacer(_key, value) {
     return value;
 }
 __name(dateToStringReplacer, "dateToStringReplacer");
-async function getHttpConfig(config3) {
+var getHttpUrl = /* @__PURE__ */ __name((config3) => {
+    const projectConfig = config3?.projectConfig;
+    const defaultUrl = "https://vercel-workflow.com/api";
+    const defaultProxyUrl = "https://api.vercel.com/v1/workflow";
+    const usingProxy = Boolean(config3?.baseUrl || projectConfig?.projectId && projectConfig?.teamId);
+    const baseUrl = config3?.baseUrl || (usingProxy ? defaultProxyUrl : defaultUrl);
+    return { baseUrl, usingProxy };
+}, "getHttpUrl");
+var getHeaders = /* @__PURE__ */ __name((config3) => {
     const projectConfig = config3?.projectConfig;
     const headers = new Headers(config3?.headers);
     if (projectConfig) {
@@ -20794,16 +20806,16 @@ async function getHttpConfig(config3) {
             headers.set("x-vercel-team-id", projectConfig.teamId);
         }
     }
+    return headers;
+}, "getHeaders");
+async function getHttpConfig(config3) {
+    const headers = getHeaders(config3);
     const token = config3?.token ?? await (0, import_oidc2.getVercelOidcToken)();
     if (token) {
         headers.set("Authorization", `Bearer ${token}`);
     }
-    let baseUrl = config3?.baseUrl;
-    if (!baseUrl) {
-        const shouldUseProxy = projectConfig?.projectId && projectConfig?.teamId;
-        baseUrl = shouldUseProxy ? `https://api.vercel.com/v1/workflow` : "https://vercel-workflow.com/api";
-    }
-    return { baseUrl, headers };
+    const { baseUrl, usingProxy } = getHttpUrl(config3);
+    return { baseUrl, headers, usingProxy };
 }
 __name(getHttpConfig, "getHttpConfig");
 async function makeRequest({ endpoint, options = {}, config: config3 = {}, schema }) {
@@ -20835,6 +20847,68 @@ curl -X ${options.method} ${stringifiedHeaders} "${url2}"`);
     }
 }
 __name(makeRequest, "makeRequest");
+// ../world-vercel/dist/queue.js
+var MessageWrapper = object({
+    payload: QueuePayloadSchema,
+    queueName: ValidQueueName
+});
+var VERCEL_QUEUE_MAX_VISIBILITY = 82800;
+function createQueue2(config3) {
+    const { baseUrl, usingProxy } = getHttpUrl(config3);
+    const headers = getHeaders(config3);
+    if (usingProxy) {
+        process.env.VERCEL_QUEUE_BASE_URL = `${baseUrl}`;
+        process.env.VERCEL_QUEUE_BASE_PATH = "/queues/v2/messages";
+        if (config3?.token) {
+            process.env.VERCEL_QUEUE_TOKEN = config3.token;
+        }
+        if (headers) {
+            headers.forEach((value, key) => {
+                const sanitizedKey = key.replaceAll("-", "__");
+                process.env[`VERCEL_QUEUE_HEADER_${sanitizedKey}`] = value;
+            });
+        }
+    }
+    const queue = /* @__PURE__ */ __name(async (queueName, x, opts) => {
+        const encoded = MessageWrapper.encode({
+            payload: x,
+            queueName
+        });
+        const sanitizedQueueName = queueName.replace(/[^A-Za-z0-9-_]/g, "-");
+        const { messageId } = await send(sanitizedQueueName, encoded, opts);
+        return { messageId: MessageId.parse(messageId) };
+    }, "queue");
+    const createQueueHandler = /* @__PURE__ */ __name((prefix, handler) => {
+        return handleCallback({
+            [`${prefix}*`]: {
+                default: /* @__PURE__ */ __name(async (body, meta) => {
+                    const { payload, queueName } = MessageWrapper.parse(body);
+                    const result = await handler(payload, {
+                        queueName,
+                        messageId: MessageId.parse(meta.messageId),
+                        attempt: meta.deliveryCount
+                    });
+                    if (typeof result?.timeoutSeconds === "number") {
+                        const adjustedTimeoutSeconds = Math.min(result.timeoutSeconds, VERCEL_QUEUE_MAX_VISIBILITY);
+                        if (adjustedTimeoutSeconds !== result.timeoutSeconds) {
+                            result.timeoutSeconds = adjustedTimeoutSeconds;
+                        }
+                    }
+                    return result;
+                }, "default")
+            }
+        });
+    }, "createQueueHandler");
+    const getDeploymentId = /* @__PURE__ */ __name(async () => {
+        const deploymentId = process.env.VERCEL_DEPLOYMENT_ID;
+        if (!deploymentId) {
+            throw new Error("VERCEL_DEPLOYMENT_ID environment variable is not set");
+        }
+        return deploymentId;
+    }, "getDeploymentId");
+    return { queue, createQueueHandler, getDeploymentId };
+}
+__name(createQueue2, "createQueue");
 // ../world-vercel/dist/events.js
 function filterEventData2(event, resolveData) {
     if (resolveData === "none") {
@@ -21336,7 +21410,7 @@ __name(createStreamer2, "createStreamer");
 // ../world-vercel/dist/index.js
 function createVercelWorld(config3) {
     return {
-        ...createQueue2(),
+        ...createQueue2(config3),
         ...createStorage2(config3),
         ...createStreamer2(config3)
     };
@@ -21921,6 +21995,7 @@ __name(stringify_primitive, "stringify_primitive");
 // ../core/dist/symbols.js
 var WORKFLOW_USE_STEP = Symbol.for("WORKFLOW_USE_STEP");
 var WORKFLOW_CREATE_HOOK = Symbol.for("WORKFLOW_CREATE_HOOK");
+var WORKFLOW_SLEEP = Symbol.for("WORKFLOW_SLEEP");
 var WORKFLOW_CONTEXT = Symbol.for("WORKFLOW_CONTEXT");
 var WORKFLOW_GET_STREAM_ID = Symbol.for("WORKFLOW_GET_STREAM_ID");
 var STREAM_NAME_SYMBOL = Symbol.for("WORKFLOW_STREAM_NAME");
@@ -21960,6 +22035,7 @@ function getCommonReducers(global2 = globalThis) {
     const viewToBase64 = /* @__PURE__ */ __name((value) => abToBase64(value.buffer, value.byteOffset, value.byteLength), "viewToBase64");
     return {
         ArrayBuffer: /* @__PURE__ */ __name((value) => value instanceof global2.ArrayBuffer && abToBase64(value, 0, value.byteLength), "ArrayBuffer"),
+        BigInt: /* @__PURE__ */ __name((value) => typeof value === "bigint" && value.toString(), "BigInt"),
         BigInt64Array: /* @__PURE__ */ __name((value) => value instanceof global2.BigInt64Array && viewToBase64(value), "BigInt64Array"),
         BigUint64Array: /* @__PURE__ */ __name((value) => value instanceof global2.BigUint64Array && viewToBase64(value), "BigUint64Array"),
         Date: /* @__PURE__ */ __name((value) => {
@@ -22079,6 +22155,7 @@ function getCommonRevivers(global2 = globalThis) {
     __name(reviveArrayBuffer, "reviveArrayBuffer");
     return {
         ArrayBuffer: reviveArrayBuffer,
+        BigInt: /* @__PURE__ */ __name((value) => global2.BigInt(value), "BigInt"),
         BigInt64Array: /* @__PURE__ */ __name((value) => {
             const ab = reviveArrayBuffer(value);
             return new global2.BigInt64Array(ab);
@@ -22266,30 +22343,6 @@ var HookFound = SemanticConvention("workflow.hook.found");
 var WebhookHandlersTriggered = SemanticConvention("webhook.handlers.triggered");
 // ../core/dist/types.js
 var import_node_util = require("node:util");
-function getConstructorName(obj) {
-    if (obj === null || obj === void 0) {
-        return null;
-    }
-    const ctor = obj.constructor;
-    if (!ctor || ctor.name === "Object") {
-        return null;
-    }
-    return ctor.name;
-}
-__name(getConstructorName, "getConstructorName");
-function getConstructorNames(obj) {
-    const proto = Object.getPrototypeOf(obj);
-    const name = getConstructorName(proto);
-    if (name === null) {
-        return [];
-    }
-    return [name, ...getConstructorNames(proto)];
-}
-__name(getConstructorNames, "getConstructorNames");
-function isInstanceOf(v, ctor) {
-    return getConstructorNames(v).includes(ctor.name);
-}
-__name(isInstanceOf, "isInstanceOf");
 function getErrorName(v) {
     if (import_node_util.types.isNativeError(v)) {
         return v.name;
@@ -22657,6 +22710,63 @@ function createCreateHook(ctx) {
     }, "createHookImpl");
 }
 __name(createCreateHook, "createCreateHook");
+// ../core/dist/workflow/sleep.js
+var import_ms3 = __toESM(require_ms(), 1);
+function createSleep(ctx) {
+    return /* @__PURE__ */ __name(async function sleepImpl(param) {
+        const { promise: promise2, resolve } = withResolvers();
+        const correlationId = `wait_${ctx.generateUlid()}`;
+        let resumeAt;
+        if (typeof param === "string") {
+            const durationMs = (0, import_ms3.default)(param);
+            if (typeof durationMs !== "number" || durationMs < 0) {
+                throw new Error(`Invalid sleep duration: "${param}". Expected a valid duration string like "1s", "1m", "1h", etc.`);
+            }
+            resumeAt = new Date(Date.now() + durationMs);
+        }
+        else if (param instanceof Date || param && typeof param === "object" && typeof param.getTime === "function") {
+            const dateParam = param instanceof Date ? param : new Date(param.getTime());
+            resumeAt = dateParam;
+        }
+        else {
+            throw new Error(`Invalid sleep parameter. Expected a duration string or Date object.`);
+        }
+        ctx.invocationsQueue.push({
+            type: "wait",
+            correlationId,
+            resumeAt
+        });
+        ctx.eventsConsumer.subscribe((event) => {
+            if (!event) {
+                setTimeout(() => {
+                    ctx.onWorkflowError(new WorkflowSuspension(ctx.invocationsQueue, ctx.globalThis));
+                }, 0);
+                return EventConsumerResult.NotConsumed;
+            }
+            if (event?.eventType === "wait_created" && event.correlationId === correlationId) {
+                const waitItem = ctx.invocationsQueue.find((item) => item.type === "wait" && item.correlationId === correlationId);
+                if (waitItem) {
+                    waitItem.hasCreatedEvent = true;
+                    waitItem.resumeAt = event.eventData.resumeAt;
+                }
+                return EventConsumerResult.Consumed;
+            }
+            if (event?.eventType === "wait_completed" && event.correlationId === correlationId) {
+                const index = ctx.invocationsQueue.findIndex((item) => item.type === "wait" && item.correlationId === correlationId);
+                if (index !== -1) {
+                    ctx.invocationsQueue.splice(index, 1);
+                }
+                setTimeout(() => {
+                    resolve();
+                }, 0);
+                return EventConsumerResult.Finished;
+            }
+            return EventConsumerResult.NotConsumed;
+        });
+        return promise2;
+    }, "sleepImpl");
+}
+__name(createSleep, "createSleep");
 // ../core/dist/workflow.js
 async function runWorkflow(workflowCode2, workflowRun, events) {
     return trace2(`WORKFLOW.run ${workflowRun.workflowName}`, async (span) => {
@@ -22694,8 +22804,10 @@ async function runWorkflow(workflowCode2, workflowRun, events) {
         });
         const useStep = createUseStep(workflowContext);
         const createHook2 = createCreateHook(workflowContext);
+        const sleep = createSleep(workflowContext);
         vmGlobalThis[WORKFLOW_USE_STEP] = useStep;
         vmGlobalThis[WORKFLOW_CREATE_HOOK] = createHook2;
+        vmGlobalThis[WORKFLOW_SLEEP] = sleep;
         vmGlobalThis[WORKFLOW_GET_STREAM_ID] = (namespace) => getWorkflowRunStreamId(workflowRun.runId, namespace);
         const url2 = process.env.VERCEL_URL ? `https://${process.env.VERCEL_URL}` : `http://localhost:${process.env.PORT || 3e3}`;
         const ctx = {
@@ -23128,6 +23240,20 @@ function workflowEntrypoint(workflowCode2) {
                         return;
                     }
                     const events = await getAllWorkflowRunEvents(workflowRun.runId);
+                    const now = Date.now();
+                    for (const event of events) {
+                        if (event.eventType === "wait_created") {
+                            const resumeAt = event.eventData.resumeAt;
+                            const hasCompleted = events.some((e) => e.eventType === "wait_completed" && e.correlationId === event.correlationId);
+                            if (!hasCompleted && now >= resumeAt.getTime()) {
+                                const completedEvent = await world.events.create(runId, {
+                                    eventType: "wait_completed",
+                                    correlationId: event.correlationId
+                                });
+                                events.push(completedEvent);
+                            }
+                        }
+                    }
                     const result = await runWorkflow(workflowCode2, workflowRun, events);
                     await world.runs.update(runId, {
                         status: "completed",
@@ -23139,10 +23265,11 @@ function workflowEntrypoint(workflowCode2) {
                     });
                 }
                 catch (err) {
-                    if (isInstanceOf(err, WorkflowSuspension)) {
-                        const suspensionMessage = buildWorkflowSuspensionMessage(runId, err.stepCount, err.hookCount);
+                    if (WorkflowSuspension.is(err)) {
+                        const suspensionMessage = buildWorkflowSuspensionMessage(runId, err.stepCount, err.hookCount, err.waitCount);
                         if (suspensionMessage) {
                         }
+                        let minTimeoutSeconds = null;
                         for (const queueItem of err.steps) {
                             if (queueItem.type === "step") {
                                 const ops = [];
@@ -23165,7 +23292,7 @@ function workflowEntrypoint(workflowCode2) {
                                     });
                                 }
                                 catch (err2) {
-                                    if (isInstanceOf(err2, WorkflowAPIError) && err2.status === 409) {
+                                    if (WorkflowAPIError.is(err2) && err2.status === 409) {
                                         console.warn(`Step "${queueItem.stepName}" with correlation ID "${queueItem.correlationId}" already exists, skipping: ${err2.message}`);
                                         continue;
                                     }
@@ -23186,7 +23313,7 @@ function workflowEntrypoint(workflowCode2) {
                                     });
                                 }
                                 catch (err2) {
-                                    if (isInstanceOf(err2, WorkflowAPIError)) {
+                                    if (WorkflowAPIError.is(err2)) {
                                         if (err2.status === 409) {
                                             console.warn(`Hook with correlation ID "${queueItem.correlationId}" already exists, skipping: ${err2.message}`);
                                             continue;
@@ -23199,11 +23326,41 @@ function workflowEntrypoint(workflowCode2) {
                                     throw err2;
                                 }
                             }
+                            else if (queueItem.type === "wait") {
+                                try {
+                                    if (!queueItem.hasCreatedEvent) {
+                                        await world.events.create(runId, {
+                                            eventType: "wait_created",
+                                            correlationId: queueItem.correlationId,
+                                            eventData: {
+                                                resumeAt: queueItem.resumeAt
+                                            }
+                                        });
+                                    }
+                                    const now = Date.now();
+                                    const resumeAtMs = queueItem.resumeAt.getTime();
+                                    const delayMs = Math.max(1e3, resumeAtMs - now);
+                                    const timeoutSeconds = Math.ceil(delayMs / 1e3);
+                                    if (minTimeoutSeconds === null || timeoutSeconds < minTimeoutSeconds) {
+                                        minTimeoutSeconds = timeoutSeconds;
+                                    }
+                                }
+                                catch (err2) {
+                                    if (WorkflowAPIError.is(err2) && err2.status === 409) {
+                                        console.warn(`Wait with correlation ID "${queueItem.correlationId}" already exists, skipping: ${err2.message}`);
+                                        continue;
+                                    }
+                                    throw err2;
+                                }
+                            }
                         }
                         span?.setAttributes({
                             ...WorkflowRunStatus("pending_steps"),
                             ...WorkflowStepsCreated(err.steps.length)
                         });
+                        if (minTimeoutSeconds !== null) {
+                            return { timeoutSeconds: minTimeoutSeconds };
+                        }
                     }
                     else {
                         const errorName = getErrorName(err);