@workflow/world-testing 4.1.0-beta.56 → 4.1.0-beta.57

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

@@ -40268,7 +40268,7 @@ async function withWindowsRetry(fn, maxRetries = 5) {
             const isRetryable = attempt < maxRetries && retryableErrors.includes(error45.code);
             if (!isRetryable)
                 throw error45;
-            const delay = baseDelayMs * Math.pow(2, attempt) + Math.random() * baseDelayMs;
+            const delay = baseDelayMs * 2 ** attempt + Math.random() * baseDelayMs;
             await new Promise((resolve2) => setTimeout(resolve2, delay));
         }
     }
@@ -40375,9 +40375,13 @@ async function deleteJSON(filePath) {
 }
 __name(deleteJSON, "deleteJSON");
 async function listJSONFiles(dirPath) {
+    return listFilesByExtension(dirPath, ".json");
+}
+__name(listJSONFiles, "listJSONFiles");
+async function listFilesByExtension(dirPath, extension) {
     try {
         const files = await import_node_fs.promises.readdir(dirPath);
-        return files.filter((f) => f.endsWith(".json")).map((f) => f.replace(".json", ""));
+        return files.filter((f) => f.endsWith(extension)).map((f) => f.slice(0, -extension.length));
     }
     catch (error45) {
         if (error45.code === "ENOENT")
@@ -40385,7 +40389,7 @@ async function listJSONFiles(dirPath) {
         throw error45;
     }
 }
-__name(listJSONFiles, "listJSONFiles");
+__name(listFilesByExtension, "listFilesByExtension");
 function parseCursor(cursor) {
     if (!cursor)
         return null;
@@ -41294,7 +41298,7 @@ function createStreamer(basedir) {
                 chunk: chunkBuffer,
                 eof: false
             });
-            const chunkPath = import_node_path8.default.join(basedir, "streams", "chunks", `${name}-${chunkId}.json`);
+            const chunkPath = import_node_path8.default.join(basedir, "streams", "chunks", `${name}-${chunkId}.bin`);
             await write(chunkPath, serialized);
             const chunkData = Uint8Array.from(chunkBuffer);
             streamEmitter.emit(`chunk:${name}`, {
@@ -41316,7 +41320,7 @@ function createStreamer(basedir) {
                     chunk: chunkBuffer,
                     eof: false
                 });
-                const chunkPath = import_node_path8.default.join(basedir, "streams", "chunks", `${name}-${chunkId}.json`);
+                const chunkPath = import_node_path8.default.join(basedir, "streams", "chunks", `${name}-${chunkId}.bin`);
                 await write(chunkPath, serialized);
                 return {
                     chunkId,
@@ -41336,7 +41340,7 @@ function createStreamer(basedir) {
             const chunkId = `chnk_${monotonicUlid2()}`;
             const runId = await _runId;
             await registerStreamForRun(runId, name);
-            const chunkPath = import_node_path8.default.join(basedir, "streams", "chunks", `${name}-${chunkId}.json`);
+            const chunkPath = import_node_path8.default.join(basedir, "streams", "chunks", `${name}-${chunkId}.bin`);
             await write(chunkPath, serializeChunk({ chunk: Buffer.from([]), eof: true }));
             streamEmitter.emit(`close:${name}`, { streamName: name });
         },
@@ -41386,8 +41390,16 @@ function createStreamer(basedir) {
                     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();
+                    const [binFiles, jsonFiles] = await Promise.all([
+                        listFilesByExtension(chunksDir, ".bin"),
+                        listFilesByExtension(chunksDir, ".json")
+                    ]);
+                    const fileExtMap = /* @__PURE__ */ new Map();
+                    for (const f of jsonFiles)
+                        fileExtMap.set(f, ".json");
+                    for (const f of binFiles)
+                        fileExtMap.set(f, ".bin");
+                    const chunkFiles = [...fileExtMap.keys()].filter((file2) => file2.startsWith(`${name}-`)).sort();
                     let isComplete = false;
                     for (let i = startIndex; i < chunkFiles.length; i++) {
                         const file2 = chunkFiles[i];
@@ -41395,7 +41407,8 @@ function createStreamer(basedir) {
                         if (deliveredChunkIds.has(chunkId)) {
                             continue;
                         }
-                        const chunk = deserializeChunk(await readBuffer(import_node_path8.default.join(chunksDir, `${file2}.json`)));
+                        const ext = fileExtMap.get(file2) ?? ".bin";
+                        const chunk = deserializeChunk(await readBuffer(import_node_path8.default.join(chunksDir, `${file2}${ext}`)));
                         if (chunk?.eof === true) {
                             isComplete = true;
                             break;
@@ -44973,10 +44986,10 @@ var getWorld = /* @__PURE__ */ __name(() => {
     return globalSymbols[WorldCache];
 }, "getWorld");
 // ../core/dist/runtime/helpers.js
-var SAFE_WORKFLOW_NAME_PATTERN = /^[a-zA-Z0-9_\-./]+$/;
+var SAFE_WORKFLOW_NAME_PATTERN = /^[a-zA-Z0-9_\-./@]+$/;
 function getWorkflowQueueName(workflowName) {
     if (!SAFE_WORKFLOW_NAME_PATTERN.test(workflowName)) {
-        throw new Error(`Invalid workflow name "${workflowName}": must only contain alphanumeric characters, underscores, hyphens, dots, or forward slashes`);
+        throw new Error(`Invalid workflow name "${workflowName}": must only contain alphanumeric characters, underscores, hyphens, dots, forward slashes, or at signs`);
     }
     return `__wkf_workflow_${workflowName}`;
 }
@@ -45144,6 +45157,30 @@ async function withThrottleRetry(fn) {
     }
 }
 __name(withThrottleRetry, "withThrottleRetry");
+async function withServerErrorRetry(fn) {
+    const delays = [500, 1e3, 2e3];
+    for (let attempt = 0; attempt <= delays.length; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            if (WorkflowAPIError.is(err) && err.status !== void 0 && err.status >= 500 && attempt < delays.length) {
+                runtimeLogger.warn("Server error (5xx) from workflow-server, retrying in-process", {
+                    status: err.status,
+                    attempt: attempt + 1,
+                    maxRetries: delays.length,
+                    nextDelayMs: delays[attempt],
+                    url: err.url
+                });
+                await new Promise((resolve2) => setTimeout(resolve2, delays[attempt]));
+                continue;
+            }
+            throw err;
+        }
+    }
+    throw new Error("withServerErrorRetry: unreachable");
+}
+__name(withServerErrorRetry, "withServerErrorRetry");
 // ../core/dist/runtime/suspension-handler.js
 var import_functions = __toESM(require_functions(), 1);
 // ../serde/dist/index.js
@@ -45944,14 +45981,19 @@ function getStreamType(stream) {
     }
 }
 __name(getStreamType, "getStreamType");
+var FRAME_HEADER_SIZE = 4;
 function getSerializeStream(reducers) {
     const encoder = new TextEncoder();
     const stream = new TransformStream({
         transform(chunk, controller) {
             try {
                 const serialized = stringify(chunk, reducers);
-                controller.enqueue(encoder.encode(`${serialized}
-`));
+                const payload = encoder.encode(serialized);
+                const prefixed = encodeWithFormatPrefix(SerializationFormat.DEVALUE_V1, payload);
+                const frame = new Uint8Array(FRAME_HEADER_SIZE + prefixed.length);
+                new DataView(frame.buffer).setUint32(0, prefixed.length, false);
+                frame.set(prefixed, FRAME_HEADER_SIZE);
+                controller.enqueue(frame);
             }
             catch (error45) {
                 controller.error(new WorkflowRuntimeError(formatSerializationError("stream chunk", error45), { slug: "serialization-failed", cause: error45 }));
@@ -45963,26 +46005,56 @@ function getSerializeStream(reducers) {
 __name(getSerializeStream, "getSerializeStream");
 function getDeserializeStream(revivers) {
     const decoder2 = new TextDecoder();
-    let buffer = "";
+    let buffer = new Uint8Array(0);
+    function appendToBuffer(data) {
+        const newBuffer = new Uint8Array(buffer.length + data.length);
+        newBuffer.set(buffer, 0);
+        newBuffer.set(data, buffer.length);
+        buffer = newBuffer;
+    }
+    __name(appendToBuffer, "appendToBuffer");
+    function processFrames(controller) {
+        while (buffer.length >= FRAME_HEADER_SIZE) {
+            const frameLength = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength).getUint32(0, false);
+            if (buffer.length < FRAME_HEADER_SIZE + frameLength) {
+                break;
+            }
+            const frameData = buffer.slice(FRAME_HEADER_SIZE, FRAME_HEADER_SIZE + frameLength);
+            buffer = buffer.slice(FRAME_HEADER_SIZE + frameLength);
+            const { format, payload } = decodeFormatPrefix(frameData);
+            if (format === SerializationFormat.DEVALUE_V1) {
+                const text = decoder2.decode(payload);
+                controller.enqueue(parse3(text, revivers));
+            }
+        }
+    }
+    __name(processFrames, "processFrames");
     const stream = new TransformStream({
         transform(chunk, controller) {
-            buffer += decoder2.decode(chunk, { stream: true });
-            while (true) {
-                const newlineIndex = buffer.indexOf("\n");
-                if (newlineIndex === -1)
-                    break;
-                const line = buffer.slice(0, newlineIndex);
-                buffer = buffer.slice(newlineIndex + 1);
+            if (buffer.length === 0 && chunk.length >= FRAME_HEADER_SIZE) {
+                const possibleLength = new DataView(chunk.buffer, chunk.byteOffset, chunk.byteLength).getUint32(0, false);
+                if (possibleLength > 0 && possibleLength < 1e8) {
+                    appendToBuffer(chunk);
+                    processFrames(controller);
+                    return;
+                }
+            }
+            else if (buffer.length > 0) {
+                appendToBuffer(chunk);
+                processFrames(controller);
+                return;
+            }
+            const text = decoder2.decode(chunk);
+            const lines = text.split("\n");
+            for (const line of lines) {
                 if (line.length > 0) {
-                    const obj = parse3(line, revivers);
-                    controller.enqueue(obj);
+                    controller.enqueue(parse3(line, revivers));
                 }
             }
         },
         flush(controller) {
-            if (buffer && buffer.length > 0) {
-                const obj = parse3(buffer, revivers);
-                controller.enqueue(obj);
+            if (buffer.length > 0) {
+                processFrames(controller);
             }
         }
     });
@@ -48447,11 +48519,11 @@ var stepHandler = getWorldHandlers().createQueueHandler("__wkf_step_", async (me
             });
             let step;
             try {
-                const startResult = await world.events.create(workflowRunId, {
+                const startResult = await withServerErrorRetry(() => world.events.create(workflowRunId, {
                     eventType: "step_started",
                     specVersion: SPEC_VERSION_CURRENT,
                     correlationId: stepId
-                });
+                }));
                 if (!startResult.step) {
                     throw new WorkflowRuntimeError(`step_started event for "${stepId}" did not return step entity`);
                 }
@@ -48487,7 +48559,7 @@ var stepHandler = getWorldHandlers().createQueueHandler("__wkf_step_", async (me
                             "step.name": stepName,
                             "step.id": stepId
                         });
-                        await queueMessage(world, `__wkf_workflow_${workflowName}`, {
+                        await queueMessage(world, getWorkflowQueueName(workflowName), {
                             runId: workflowRunId,
                             traceCarrier: await serializeTraceCarrier(),
                             requestedAt: /* @__PURE__ */ new Date()
@@ -48615,21 +48687,21 @@ var stepHandler = getWorldHandlers().createQueueHandler("__wkf_step_", async (me
                         throw err;
                 }));
                 const [, traceCarrier] = await Promise.all([
-                    world.events.create(workflowRunId, {
+                    withServerErrorRetry(() => world.events.create(workflowRunId, {
                         eventType: "step_completed",
                         specVersion: SPEC_VERSION_CURRENT,
                         correlationId: stepId,
                         eventData: {
                             result
                         }
-                    }),
+                    })),
                     serializeTraceCarrier()
                 ]);
                 span?.setAttributes({
                     ...StepStatus("completed"),
                     ...StepResultType(typeof result)
                 });
-                await queueMessage(world, `__wkf_workflow_${workflowName}`, {
+                await queueMessage(world, getWorkflowQueueName(workflowName), {
                     runId: workflowRunId,
                     traceCarrier,
                     requestedAt: /* @__PURE__ */ new Date()
@@ -48661,6 +48733,16 @@ var stepHandler = getWorldHandlers().createQueueHandler("__wkf_step_", async (me
                         });
                         return;
                     }
+                    if (err.status !== void 0 && err.status >= 500) {
+                        runtimeLogger.warn("Persistent server error (5xx) during step, deferring to queue retry", {
+                            status: err.status,
+                            workflowRunId,
+                            stepId,
+                            error: err.message,
+                            url: err.url
+                        });
+                        throw err;
+                    }
                 }
                 if (isFatal) {
                     stepLogger.error("Encountered FatalError while executing step, bubbling up to parent workflow", {
@@ -48668,7 +48750,7 @@ var stepHandler = getWorldHandlers().createQueueHandler("__wkf_step_", async (me
                         stepName,
                         errorStack: normalizedStack
                     });
-                    await world.events.create(workflowRunId, {
+                    await withServerErrorRetry(() => world.events.create(workflowRunId, {
                         eventType: "step_failed",
                         specVersion: SPEC_VERSION_CURRENT,
                         correlationId: stepId,
@@ -48676,7 +48758,7 @@ var stepHandler = getWorldHandlers().createQueueHandler("__wkf_step_", async (me
                             error: normalizedError.message,
                             stack: normalizedStack
                         }
-                    });
+                    }));
                     span?.setAttributes({
                         ...StepStatus("failed"),
                         ...StepFatalError(true)
@@ -48699,7 +48781,7 @@ var stepHandler = getWorldHandlers().createQueueHandler("__wkf_step_", async (me
                             errorStack: normalizedStack
                         });
                         const errorMessage = `Step "${stepName}" failed after ${maxRetries2} ${pluralize("retry", "retries", maxRetries2)}: ${normalizedError.message}`;
-                        await world.events.create(workflowRunId, {
+                        await withServerErrorRetry(() => world.events.create(workflowRunId, {
                             eventType: "step_failed",
                             specVersion: SPEC_VERSION_CURRENT,
                             correlationId: stepId,
@@ -48707,7 +48789,7 @@ var stepHandler = getWorldHandlers().createQueueHandler("__wkf_step_", async (me
                                 error: errorMessage,
                                 stack: normalizedStack
                             }
-                        });
+                        }));
                         span?.setAttributes({
                             ...StepStatus("failed"),
                             ...StepRetryExhausted(true)
@@ -48730,7 +48812,7 @@ var stepHandler = getWorldHandlers().createQueueHandler("__wkf_step_", async (me
                                 errorStack: normalizedStack
                             });
                         }
-                        await world.events.create(workflowRunId, {
+                        await withServerErrorRetry(() => world.events.create(workflowRunId, {
                             eventType: "step_retrying",
                             specVersion: SPEC_VERSION_CURRENT,
                             correlationId: stepId,
@@ -48741,7 +48823,7 @@ var stepHandler = getWorldHandlers().createQueueHandler("__wkf_step_", async (me
                                     retryAfter: err.retryAfter
                                 }
                             }
-                        });
+                        }));
                         const timeoutSeconds = Math.max(1, RetryableError.is(err) ? Math.ceil((+err.retryAfter.getTime() - Date.now()) / 1e3) : 1);
                         span?.setAttributes({
                             ...StepRetryTimeoutSeconds(timeoutSeconds),
@@ -49172,7 +49254,7 @@ function getWritable(options = {}) {
 __name(getWritable, "getWritable");
 
 // ../workflow/dist/stdlib.js
-var fetch = globalThis[Symbol.for("WORKFLOW_USE_STEP")]("step//workflow@4.1.0-beta.55//fetch");
+var fetch = globalThis[Symbol.for("WORKFLOW_USE_STEP")]("step//workflow@4.1.0-beta.56//fetch");
 
 // ../../node_modules/.pnpm/zod@4.1.11/node_modules/zod/v4/core/core.js
 var NEVER = Object.freeze({