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

package/dist/.well-known/workflow/v1/manifest.json

@@ -1,27 +1,6 @@
 {
     "version": "1.0.0",
     "steps": {
-        "workflows/addition.ts": {
-            "add": {
-                "stepId": "step//./workflows/addition//add"
-            }
-        },
-        "workflow/dist/internal/builtins.js": {
-            "__builtin_response_array_buffer": {
-                "stepId": "__builtin_response_array_buffer"
-            },
-            "__builtin_response_json": {
-                "stepId": "__builtin_response_json"
-            },
-            "__builtin_response_text": {
-                "stepId": "__builtin_response_text"
-            }
-        },
-        "workflow/dist/stdlib.js": {
-            "fetch": {
-                "stepId": "step//workflow@4.1.0-beta.55//fetch"
-            }
-        },
         "workflows/hooks.ts": {
             "writeEvent": {
                 "stepId": "step//./workflows/hooks//writeEvent"
@@ -32,6 +11,11 @@
                 "stepId": "step//./workflows/noop//noop"
             }
         },
+        "workflows/addition.ts": {
+            "add": {
+                "stepId": "step//./workflows/addition//add"
+            }
+        },
         "workflows/null-byte.ts": {
             "nullByteStep": {
                 "stepId": "step//./workflows/null-byte//nullByteStep"
@@ -44,18 +28,25 @@
             "stepThatThrowsRetryableError": {
                 "stepId": "step//./workflows/retriable-and-fatal//stepThatThrowsRetryableError"
             }
+        },
+        "workflow/dist/internal/builtins.js": {
+            "__builtin_response_array_buffer": {
+                "stepId": "__builtin_response_array_buffer"
+            },
+            "__builtin_response_json": {
+                "stepId": "__builtin_response_json"
+            },
+            "__builtin_response_text": {
+                "stepId": "__builtin_response_text"
+            }
+        },
+        "workflow/dist/stdlib.js": {
+            "fetch": {
+                "stepId": "step//workflow@4.1.0-beta.57//fetch"
+            }
         }
     },
     "workflows": {
-        "workflows/addition.ts": {
-            "addition": {
-                "workflowId": "workflow//./workflows/addition//addition",
-                "graph": {
-                    "nodes": [],
-                    "edges": []
-                }
-            }
-        },
         "workflows/hooks.ts": {
             "collectWithHook": {
                 "workflowId": "workflow//./workflows/hooks//collectWithHook",
@@ -74,6 +65,15 @@
                 }
             }
         },
+        "workflows/addition.ts": {
+            "addition": {
+                "workflowId": "workflow//./workflows/addition//addition",
+                "graph": {
+                    "nodes": [],
+                    "edges": []
+                }
+            }
+        },
         "workflows/null-byte.ts": {
             "nullByteWorkflow": {
                 "workflowId": "workflow//./workflows/null-byte//nullByteWorkflow",

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

@@ -25191,7 +25191,7 @@ async function fetch2(...args) {
     return globalThis.fetch(...args);
 }
 __name(fetch2, "fetch");
-registerStepFunction("step//workflow@4.1.0-beta.55//fetch", fetch2);
+registerStepFunction("step//workflow@4.1.0-beta.57//fetch", fetch2);
 // workflows/addition.ts
 async function add(num, num2) {
     return num + num2;
@@ -43345,7 +43345,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));
         }
     }
@@ -43458,9 +43458,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")
@@ -43468,7 +43472,7 @@ async function listJSONFiles(dirPath) {
         throw error45;
     }
 }
-__name(listJSONFiles, "listJSONFiles");
+__name(listFilesByExtension, "listFilesByExtension");
 function parseCursor(cursor) {
     if (!cursor)
         return null;
@@ -44435,7 +44439,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}`, {
@@ -44457,7 +44461,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,
@@ -44477,7 +44481,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
@@ -44532,8 +44536,18 @@ 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];
@@ -44541,7 +44555,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;
@@ -48331,14 +48346,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), {
@@ -48353,28 +48373,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);
             }
         }
     });
@@ -48919,10 +48967,10 @@ async function waitedUntil(fn) {
 }
 __name(waitedUntil, "waitedUntil");
 // ../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}`;
 }
@@ -49018,6 +49066,34 @@ function getQueueOverhead(message) {
     }
 }
 __name(getQueueOverhead, "getQueueOverhead");
+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/resume-hook.js
 async function getHookByToken2(token) {
     const world = getWorld();
@@ -49344,11 +49420,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`);
                 }
@@ -49386,7 +49462,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()
@@ -49518,21 +49594,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()
@@ -49564,6 +49640,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", {
@@ -49571,7 +49657,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,
@@ -49579,7 +49665,7 @@ var stepHandler = getWorldHandlers().createQueueHandler("__wkf_step_", async (me
                             error: normalizedError.message,
                             stack: normalizedStack
                         }
-                    });
+                    }));
                     span?.setAttributes({
                         ...StepStatus("failed"),
                         ...StepFatalError(true)
@@ -49602,7 +49688,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,
@@ -49610,7 +49696,7 @@ var stepHandler = getWorldHandlers().createQueueHandler("__wkf_step_", async (me
                                 error: errorMessage,
                                 stack: normalizedStack
                             }
-                        });
+                        }));
                         span?.setAttributes({
                             ...StepStatus("failed"),
                             ...StepRetryExhausted(true)
@@ -49633,7 +49719,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,
@@ -49644,7 +49730,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),