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

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

@@ -5257,6 +5257,14 @@ __name(__builtin_response_text, "__builtin_response_text");
 registerStepFunction("__builtin_response_array_buffer", __builtin_response_array_buffer);
 registerStepFunction("__builtin_response_json", __builtin_response_json);
 registerStepFunction("__builtin_response_text", __builtin_response_text);
+// workflows/noop.ts
+var count = 0;
+async function noop(_i) {
+    count++;
+    return count;
+}
+__name(noop, "noop");
+registerStepFunction("step//workflows/noop.ts//noop", noop);
 // ../errors/dist/index.js
 var import_ms = __toESM(require_ms(), 1);
 var BASE_URL = "https://useworkflow.dev/err";
@@ -5912,509 +5920,50 @@ var config = once(() => {
 });
 // ../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) {
@@ -21256,220 +20805,679 @@ function createStorage(basedir) {
                         })
                     };
                 }
-                return result;
+                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;
+                    }
+                }
+                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,
+                    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;
+            }
+        }
+    };
+}
+__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 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();
+                }
+            });
+        }
+    };
+}
+__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/mixpart@0.0.5-alpha.1/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;
+                }
             }
-        },
-        // 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`);
+        }
+        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
+            ]);
+        }
+    }
+    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");
+    }
+    return boundaryMatch[1] ?? boundaryMatch[2];
+}
+__name(extractBoundary, "extractBoundary");
+var AsyncMessageQueue = 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);
+            }
+        }
+    }
+    /**
+    * 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);
+        }
+    }
+    /**
+    * 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
+            });
+        });
+    }
+    /**
+    * Check if the queue is in a terminal state
+    */
+    get isTerminal() {
+        return this.finished || this.cancelled;
+    }
+};
+async function* parseMultipartStream2(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(parseMultipartStream2, "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();
                 }
-                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;
+                catch (readError) {
+                    if (readError instanceof Error && (readError.name === "AbortError" || readError.constructor.name === "AbortError" || readError.name === "TimeoutError" || readError.constructor.name === "TimeoutError")) {
+                        break;
                     }
+                    throw readError;
                 }
-                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,
-                    filter: /* @__PURE__ */ __name((hook) => {
-                        if (params.runId && hook.runId !== params.runId) {
-                            return false;
+                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);
                         }
-                        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`);
+                    }
+                    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;
                 }
-                await deleteJSON(hookPath);
-                return hook;
+                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();
             }
         }
-    };
-}
-__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}`);
                     }
-                    isReadingFromDisk = false;
-                    bufferedEventChunks.sort((a, b) => a.chunkId.localeCompare(b.chunkId));
-                    for (const buffered of bufferedEventChunks) {
-                        controller.enqueue(buffered.chunkData);
+                    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}`);
                     }
-                    if (isComplete) {
-                        removeListeners();
-                        controller.close();
-                        return;
+                    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`);
                     }
-                },
-                cancel() {
-                    removeListeners();
+                    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;
+            }
         }
-    };
-}
-__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;
@@ -21644,15 +21652,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) {
@@ -21679,7 +21694,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) {
@@ -21694,8 +21710,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) {
@@ -21741,7 +21757,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());
@@ -21781,7 +21798,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) {
@@ -21808,7 +21825,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());
@@ -21868,7 +21886,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) {
@@ -21919,7 +21937,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) {
@@ -21967,7 +21986,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) {
@@ -22130,7 +22150,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) {
@@ -22146,45 +22165,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);
             }
@@ -22196,7 +22184,6 @@ function registerDevRouteHandler(routeHandler, handlers) {
             }
         }
     }
-    routeHandlerKeys.set(routeHandler, keys);
 }
 __name(registerDevRouteHandler, "registerDevRouteHandler");
 function findRouteHandlersForTopic(topicName) {
@@ -22590,51 +22577,6 @@ async function send(topicName, payload, options) {
     };
 }
 __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";
@@ -22645,7 +22587,18 @@ 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) {
@@ -22657,18 +22610,19 @@ 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";
-    }
+    const { baseUrl, usingProxy } = getHttpUrl(config3);
     return {
         baseUrl,
-        headers
+        headers,
+        usingProxy
     };
 }
 __name(getHttpConfig, "getHttpConfig");
@@ -22711,6 +22665,66 @@ curl -X ${options.method} ${stringifiedHeaders} "${url2}"`);
     }
 }
 __name(makeRequest, "makeRequest");
+// ../world-vercel/dist/queue.js
+var MessageWrapper = object({
+    payload: QueuePayloadSchema,
+    queueName: ValidQueueName
+});
+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((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/events.js
 function filterEventData2(event, resolveData) {
     if (resolveData === "none") {
@@ -23236,7 +23250,7 @@ __name(createStreamer2, "createStreamer");
 // ../world-vercel/dist/index.js
 function createVercelWorld(config3) {
     return {
-        ...createQueue2(),
+        ...createQueue2(config3),
         ...createStorage2(config3),
         ...createStreamer2(config3)
     };
@@ -23440,6 +23454,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) => {
@@ -23569,6 +23584,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);
@@ -23898,14 +23914,6 @@ async function add(num, num2) {
 }
 __name(add, "add");
 registerStepFunction("step//workflows/addition.ts//add", add);
-// workflows/noop.ts
-var count = 0;
-async function noop(_i) {
-    count++;
-    return count;
-}
-__name(noop, "noop");
-registerStepFunction("step//workflows/noop.ts//noop", noop);
 // ../core/dist/runtime.js
 var import_functions3 = __toESM(require_functions(), 1);
 // ../core/dist/logger.js