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

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

@@ -5124,503 +5124,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) {
@@ -18740,907 +18287,1360 @@ function decodeTime(id) {
     if (time3 > TIME_MAX) {
         throw new ULIDError(ULIDErrorCode.DecodeTimeValueMalformed, `Malformed ULID: timestamp too large: ${time3}`);
     }
-    return 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
+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 retryIn = Number(JSON.parse(text).retryIn);
+                        await (0, import_promises.setTimeout)(retryIn * 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 response = await handler(body, { attempt, queueName, messageId });
+                const retryIn = typeof response === "undefined" ? null : response.timeoutSeconds;
+                if (retryIn) {
+                    return Response.json({ retryIn }, { 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(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;
-        };
+__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;
+            }
+        }
     }
-    else if (typeof globalCrypto?.randomBytes === "function") {
-        return () => globalCrypto.randomBytes(1).readUInt8() / 255;
+    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);
     }
-    else if (import_node_crypto.default?.randomBytes) {
-        return () => import_node_crypto.default.randomBytes(1).readUInt8() / 255;
+    catch (error45) {
+        await import_node_fs.promises.unlink(tempPath).catch(() => {
+        });
+        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(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));
     }
-    if (typeof globalThis !== "undefined") {
-        return globalThis;
+    catch (error45) {
+        if (error45.code === "ENOENT")
+            return null;
+        throw error45;
     }
-    return null;
 }
-__name(detectRoot, "detectRoot");
-function encodeRandom(len, prng) {
-    let str = "";
-    for (; len > 0; len--) {
-        str = randomChar(prng) + str;
+__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;
     }
-    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}`);
+__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", ""));
     }
-    else if (now > TIME_MAX) {
-        throw new ULIDError(ULIDErrorCode.EncodeTimeSizeExceeded, `Cannot encode a time larger than ${TIME_MAX}: ${now}`);
+    catch (error45) {
+        if (error45.code === "ENOENT")
+            return [];
+        throw error45;
     }
-    else if (now < 0) {
-        throw new ULIDError(ULIDErrorCode.EncodeTimeNegative, `Time must be positive: ${now}`);
+}
+__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;
+                }
+            }
+            return false;
+        });
     }
-    else if (Number.isInteger(now) === false) {
-        throw new ULIDError(ULIDErrorCode.EncodeTimeValueMalformed, `Time must be an integer: ${now}`);
+    else {
+        candidateFileIds = relevantFileIds.filter((fileId) => {
+            return getCreatedAt(`${fileId}.json`) !== null;
+        });
     }
-    let mod, str = "";
-    for (let currentLen = len; currentLen > 0; currentLen--) {
-        mod = now % ENCODING_LEN;
-        str = ENCODING.charAt(mod) + str;
-        now = (now - mod) / ENCODING_LEN;
+    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);
+        }
     }
-    return str;
+    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(encodeTime, "encodeTime");
-function inWebWorker() {
-    return typeof WorkerGlobalScope !== "undefined" && self instanceof WorkerGlobalScope;
+__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(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(filterRunData, "filterRunData");
+function filterStepData(step, resolveData) {
+    if (resolveData === "none") {
+        return {
+            ...step,
+            input: [],
+            output: void 0
+        };
+    }
+    return step;
 }
-__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(filterStepData, "filterStepData");
+function filterEventData(event, resolveData) {
+    if (resolveData === "none") {
+        const { eventData: _eventData, ...rest } = event;
+        return rest;
+    }
+    return event;
+}
+__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;
-                }
-                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 {
-                    }
+                if (resolveData === "none") {
+                    return {
+                        ...result,
+                        data: result.data.map((event) => {
+                            const { eventData: _eventData, ...rest } = event;
+                            return rest;
+                        })
+                    };
                 }
-                console.error(`[embedded world] Failed to queue message`, {
-                    queueName,
-                    text,
-                    status: response.status,
-                    headers: Object.fromEntries(response.headers.entries()),
-                    body: body.toString()
+                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")
                 });
-            }
-            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 response = await handler(body, { attempt, queueName, messageId });
-                const retryIn = typeof response === "undefined" ? null : response.timeoutSeconds;
-                if (retryIn) {
-                    return Response.json({ retryIn }, { status: 503 });
+                if (resolveData === "none") {
+                    return {
+                        ...result,
+                        data: result.data.map((event) => {
+                            const { eventData: _eventData, ...rest } = event;
+                            return rest;
+                        })
+                    };
                 }
-                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;
+                return result;
             }
-        }
-    }
-    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;
-    }
-}
-__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(readJSON, "readJSON");
-async function readBuffer(filePath) {
-    const content = await import_node_fs.promises.readFile(filePath);
-    return content;
+        },
+        // 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,
+                    // 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;
+            }
+        }
+    };
 }
-__name(readBuffer, "readBuffer");
-async function deleteJSON(filePath) {
-    try {
-        await import_node_fs.promises.unlink(filePath);
-    }
-    catch (error45) {
-        if (error45.code !== "ENOENT")
-            throw error45;
-    }
+__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(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", ""));
-    }
-    catch (error45) {
-        if (error45.code === "ENOENT")
-            return [];
-        throw error45;
-    }
+__name(serializeChunk, "serializeChunk");
+function deserializeChunk(serialized) {
+    const eof = serialized[0] === 1;
+    const chunk = serialized.subarray(1);
+    return { eof, chunk };
 }
-__name(listJSONFiles, "listJSONFiles");
-function parseCursor(cursor) {
-    if (!cursor)
-        return null;
-    const parts = cursor.split("|");
+__name(deserializeChunk, "deserializeChunk");
+function createStreamer(basedir) {
+    const streamEmitter = new import_node_events.EventEmitter();
     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;
-                }
+        async writeToStream(name, chunk) {
+            const chunkId = `strm_${monotonicUlid2()}`;
+            if (typeof chunk === "string") {
+                chunk = new TextEncoder().encode(chunk);
             }
-            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)
+            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);
+                        }
                     }
-                }
-                else {
-                    if (itemTime < cursorTime)
-                        continue;
-                    if (itemTime === cursorTime && parsedCursor.id && getId) {
-                        const itemId = getId(item);
-                        if (itemId <= parsedCursor.id)
-                            continue;
+                    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();
                 }
-            }
-            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);
+            });
         }
-        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;
+    };
+}
+__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 {
-        data: items,
-        cursor: nextCursor,
-        hasMore
+        ...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;
+                }
+            }
+        }
+        return -1;
     };
 }
-__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
-        };
+__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 run;
+    return new Headers(headerInit);
 }
-__name(filterRunData, "filterRunData");
-function filterStepData(step, resolveData) {
-    if (resolveData === "none") {
-        return {
-            ...step,
-            input: [],
-            output: void 0
-        };
+__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 step;
+    return boundaryMatch[1] ?? boundaryMatch[2];
 }
-__name(filterStepData, "filterStepData");
-function filterEventData(event, resolveData) {
-    if (resolveData === "none") {
-        const { eventData: _eventData, ...rest } = event;
-        return rest;
+__name(extractBoundary, "extractBoundary");
+var AsyncMessageQueue = class {
+    static {
+        __name(this, "AsyncMessageQueue");
     }
-    return event;
-}
-__name(filterEventData, "filterEventData");
-function filterHookData(hook, resolveData) {
-    if (resolveData === "none") {
-        const { metadata: _metadata, ...rest } = hook;
-        return rest;
+    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);
+        }
     }
-    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);
+    /**
+     * 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);
+            }
+        }
     }
-    if (idPrefix === "step") {
-        const runId = filename.substring(0, dashIndex);
-        const ulid5 = runId.replace(/^wrun_/, "");
-        return ulidToDate(ulid5);
+    /**
+     * 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);
+        }
     }
-    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);
+    /**
+     * 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();
             }
-        },
-        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;
                 }
-                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}`);
+                    }
+                    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 +19815,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 +19857,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 +19873,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 +19920,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 +19961,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 +19988,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 +20047,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 +20096,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 +20143,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 +20289,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 +20304,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 +20323,6 @@ function registerDevRouteHandler(routeHandler, handlers) {
             }
         }
     }
-    routeHandlerKeys.set(routeHandler, keys);
 }
 __name(registerDevRouteHandler, "registerDevRouteHandler");
 function findRouteHandlersForTopic(topicName) {
@@ -20733,45 +20712,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 +20722,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 +20742,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 +20783,60 @@ 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") {
@@ -21336,7 +21338,7 @@ __name(createStreamer2, "createStreamer");
 // ../world-vercel/dist/index.js
 function createVercelWorld(config3) {
     return {
-        ...createQueue2(),
+        ...createQueue2(config3),
         ...createStorage2(config3),
         ...createStreamer2(config3)
     };
@@ -21960,6 +21962,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 +22082,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);
@@ -23237,25 +23241,6 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// workflows/addition.ts
-var addition_exports = {};
-__export(addition_exports, {
-  addition: () => addition
-});
-async function add(num, num2) {
-  return globalThis[Symbol.for("WORKFLOW_USE_STEP")]("step//workflows/addition.ts//add")(num, num2);
-}
-__name(add, "add");
-async function addition(num, num2) {
-  const result = await add(num, num2);
-  console.log({
-    result
-  });
-  return result;
-}
-__name(addition, "addition");
-addition.workflowId = "workflow//workflows/addition.ts//addition";
-
 // workflows/noop.ts
 var noop_exports = {};
 __export(noop_exports, {
@@ -23292,10 +23277,29 @@ async function brokenWf() {
 __name(brokenWf, "brokenWf");
 brokenWf.workflowId = "workflow//workflows/noop.ts//brokenWf";
 
+// workflows/addition.ts
+var addition_exports = {};
+__export(addition_exports, {
+  addition: () => addition
+});
+async function add(num, num2) {
+  return globalThis[Symbol.for("WORKFLOW_USE_STEP")]("step//workflows/addition.ts//add")(num, num2);
+}
+__name(add, "add");
+async function addition(num, num2) {
+  const result = await add(num, num2);
+  console.log({
+    result
+  });
+  return result;
+}
+__name(addition, "addition");
+addition.workflowId = "workflow//workflows/addition.ts//addition";
+
 // virtual-entry.js
 globalThis.__private_workflows = /* @__PURE__ */ new Map();
-Object.values(addition_exports).map((item) => item?.workflowId && globalThis.__private_workflows.set(item.workflowId, item));
 Object.values(noop_exports).map((item) => item?.workflowId && globalThis.__private_workflows.set(item.workflowId, item));
+Object.values(addition_exports).map((item) => item?.workflowId && globalThis.__private_workflows.set(item.workflowId, item));
 `;
 var POST = workflowEntrypoint(workflowCode);
 // Annotate the CommonJS export names for ESM import in node: