@workflow/world-testing 4.1.0-beta.65 → 4.1.0-beta.66

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

@@ -45611,6 +45611,193 @@ var WaitSchema = external_exports.object({
   specVersion: external_exports.number().optional()
 });
 
+// ../../node_modules/.pnpm/ulid@3.0.1/node_modules/ulid/dist/node/index.js
+var import_node_crypto = __toESM(require("node:crypto"), 1);
+var ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
+var ENCODING_LEN = 32;
+var RANDOM_LEN = 16;
+var TIME_LEN = 10;
+var TIME_MAX = 281474976710655;
+var ULIDErrorCode;
+(function(ULIDErrorCode2) {
+  ULIDErrorCode2["Base32IncorrectEncoding"] = "B32_ENC_INVALID";
+  ULIDErrorCode2["DecodeTimeInvalidCharacter"] = "DEC_TIME_CHAR";
+  ULIDErrorCode2["DecodeTimeValueMalformed"] = "DEC_TIME_MALFORMED";
+  ULIDErrorCode2["EncodeTimeNegative"] = "ENC_TIME_NEG";
+  ULIDErrorCode2["EncodeTimeSizeExceeded"] = "ENC_TIME_SIZE_EXCEED";
+  ULIDErrorCode2["EncodeTimeValueMalformed"] = "ENC_TIME_MALFORMED";
+  ULIDErrorCode2["PRNGDetectFailure"] = "PRNG_DETECT";
+  ULIDErrorCode2["ULIDInvalid"] = "ULID_INVALID";
+  ULIDErrorCode2["Unexpected"] = "UNEXPECTED";
+  ULIDErrorCode2["UUIDInvalid"] = "UUID_INVALID";
+})(ULIDErrorCode || (ULIDErrorCode = {}));
+var ULIDError = class extends Error {
+  static {
+    __name(this, "ULIDError");
+  }
+  constructor(errorCode, message) {
+    super(`${message} (${errorCode})`);
+    this.name = "ULIDError";
+    this.code = errorCode;
+  }
+};
+function randomChar(prng) {
+  const randomPosition = Math.floor(prng() * ENCODING_LEN) % ENCODING_LEN;
+  return ENCODING.charAt(randomPosition);
+}
+__name(randomChar, "randomChar");
+function replaceCharAt(str, index, char) {
+  if (index > str.length - 1) {
+    return str;
+  }
+  return str.substr(0, index) + char + str.substr(index + 1);
+}
+__name(replaceCharAt, "replaceCharAt");
+function incrementBase32(str) {
+  let done = void 0, index = str.length, char, charIndex, output = str;
+  const maxCharIndex = ENCODING_LEN - 1;
+  while (!done && index-- >= 0) {
+    char = output[index];
+    charIndex = ENCODING.indexOf(char);
+    if (charIndex === -1) {
+      throw new ULIDError(ULIDErrorCode.Base32IncorrectEncoding, "Incorrectly encoded string");
+    }
+    if (charIndex === maxCharIndex) {
+      output = replaceCharAt(output, index, ENCODING[0]);
+      continue;
+    }
+    done = replaceCharAt(output, index, ENCODING[charIndex + 1]);
+  }
+  if (typeof done === "string") {
+    return done;
+  }
+  throw new ULIDError(ULIDErrorCode.Base32IncorrectEncoding, "Failed incrementing string");
+}
+__name(incrementBase32, "incrementBase32");
+function decodeTime(id) {
+  if (id.length !== TIME_LEN + RANDOM_LEN) {
+    throw new ULIDError(ULIDErrorCode.DecodeTimeValueMalformed, "Malformed ULID");
+  }
+  const time3 = id.substr(0, TIME_LEN).toUpperCase().split("").reverse().reduce((carry, char, index) => {
+    const encodingIndex = ENCODING.indexOf(char);
+    if (encodingIndex === -1) {
+      throw new ULIDError(ULIDErrorCode.DecodeTimeInvalidCharacter, `Time decode error: Invalid character: ${char}`);
+    }
+    return carry += encodingIndex * Math.pow(ENCODING_LEN, index);
+  }, 0);
+  if (time3 > TIME_MAX) {
+    throw new ULIDError(ULIDErrorCode.DecodeTimeValueMalformed, `Malformed ULID: timestamp too large: ${time3}`);
+  }
+  return time3;
+}
+__name(decodeTime, "decodeTime");
+function detectPRNG(root) {
+  const rootLookup = detectRoot();
+  const globalCrypto = rootLookup && (rootLookup.crypto || rootLookup.msCrypto) || (typeof import_node_crypto.default !== "undefined" ? import_node_crypto.default : null);
+  if (typeof globalCrypto?.getRandomValues === "function") {
+    return () => {
+      const buffer = new Uint8Array(1);
+      globalCrypto.getRandomValues(buffer);
+      return buffer[0] / 255;
+    };
+  } else if (typeof globalCrypto?.randomBytes === "function") {
+    return () => globalCrypto.randomBytes(1).readUInt8() / 255;
+  } else if (import_node_crypto.default?.randomBytes) {
+    return () => import_node_crypto.default.randomBytes(1).readUInt8() / 255;
+  }
+  throw new ULIDError(ULIDErrorCode.PRNGDetectFailure, "Failed to find a reliable PRNG");
+}
+__name(detectPRNG, "detectPRNG");
+function detectRoot() {
+  if (inWebWorker())
+    return self;
+  if (typeof window !== "undefined") {
+    return window;
+  }
+  if (typeof global !== "undefined") {
+    return global;
+  }
+  if (typeof globalThis !== "undefined") {
+    return globalThis;
+  }
+  return null;
+}
+__name(detectRoot, "detectRoot");
+function encodeRandom(len, prng) {
+  let str = "";
+  for (; len > 0; len--) {
+    str = randomChar(prng) + str;
+  }
+  return str;
+}
+__name(encodeRandom, "encodeRandom");
+function encodeTime(now, len = TIME_LEN) {
+  if (isNaN(now)) {
+    throw new ULIDError(ULIDErrorCode.EncodeTimeValueMalformed, `Time must be a number: ${now}`);
+  } else if (now > TIME_MAX) {
+    throw new ULIDError(ULIDErrorCode.EncodeTimeSizeExceeded, `Cannot encode a time larger than ${TIME_MAX}: ${now}`);
+  } else if (now < 0) {
+    throw new ULIDError(ULIDErrorCode.EncodeTimeNegative, `Time must be positive: ${now}`);
+  } else if (Number.isInteger(now) === false) {
+    throw new ULIDError(ULIDErrorCode.EncodeTimeValueMalformed, `Time must be an integer: ${now}`);
+  }
+  let mod, str = "";
+  for (let currentLen = len; currentLen > 0; currentLen--) {
+    mod = now % ENCODING_LEN;
+    str = ENCODING.charAt(mod) + str;
+    now = (now - mod) / ENCODING_LEN;
+  }
+  return str;
+}
+__name(encodeTime, "encodeTime");
+function inWebWorker() {
+  return typeof WorkerGlobalScope !== "undefined" && self instanceof WorkerGlobalScope;
+}
+__name(inWebWorker, "inWebWorker");
+function monotonicFactory(prng) {
+  const currentPRNG = prng || detectPRNG();
+  let lastTime = 0, lastRandom;
+  return /* @__PURE__ */ __name(function _ulid2(seedTime) {
+    const seed = !seedTime || isNaN(seedTime) ? Date.now() : seedTime;
+    if (seed <= lastTime) {
+      const incrementedRandom = lastRandom = incrementBase32(lastRandom);
+      return encodeTime(lastTime, TIME_LEN) + incrementedRandom;
+    }
+    lastTime = seed;
+    const newRandom = lastRandom = encodeRandom(RANDOM_LEN, currentPRNG);
+    return encodeTime(seed, TIME_LEN) + newRandom;
+  }, "_ulid");
+}
+__name(monotonicFactory, "monotonicFactory");
+
+// ../world/dist/ulid.js
+var UlidSchema = external_exports.string().ulid();
+var DEFAULT_TIMESTAMP_THRESHOLD_MS = 5 * 60 * 1e3;
+function ulidToDate(maybeUlid) {
+  const ulid5 = UlidSchema.safeParse(maybeUlid);
+  if (!ulid5.success) {
+    return null;
+  }
+  return new Date(decodeTime(ulid5.data));
+}
+__name(ulidToDate, "ulidToDate");
+function validateUlidTimestamp(prefixedUlid, prefix, thresholdMs = DEFAULT_TIMESTAMP_THRESHOLD_MS) {
+  const raw = prefixedUlid.startsWith(prefix) ? prefixedUlid.slice(prefix.length) : prefixedUlid;
+  const ulidTimestamp = ulidToDate(raw);
+  if (!ulidTimestamp) {
+    return `Invalid runId: "${prefixedUlid}" is not a valid ULID`;
+  }
+  const serverTimestamp = /* @__PURE__ */ new Date();
+  const driftMs = Math.abs(serverTimestamp.getTime() - ulidTimestamp.getTime());
+  if (driftMs <= thresholdMs) {
+    return null;
+  }
+  const driftSeconds = Math.round(driftMs / 1e3);
+  const thresholdSeconds = Math.round(thresholdMs / 1e3);
+  return `Invalid runId timestamp: embedded timestamp differs from server time by ${driftSeconds}s (threshold: ${thresholdSeconds}s)`;
+}
+__name(validateUlidTimestamp, "validateUlidTimestamp");
+
 // ../core/dist/encryption.js
 var NONCE_LENGTH = 12;
 var TAG_LENGTH = 128;
@@ -45948,169 +46135,13 @@ var webhookLogger = createLogger("webhook");
 var eventsLogger = createLogger("events");
 var adapterLogger = createLogger("adapter");
 
-// ../../node_modules/.pnpm/ulid@3.0.1/node_modules/ulid/dist/node/index.js
-var import_node_crypto = __toESM(require("node:crypto"), 1);
-var ENCODING = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
-var ENCODING_LEN = 32;
-var RANDOM_LEN = 16;
-var TIME_LEN = 10;
-var TIME_MAX = 281474976710655;
-var ULIDErrorCode;
-(function(ULIDErrorCode2) {
-  ULIDErrorCode2["Base32IncorrectEncoding"] = "B32_ENC_INVALID";
-  ULIDErrorCode2["DecodeTimeInvalidCharacter"] = "DEC_TIME_CHAR";
-  ULIDErrorCode2["DecodeTimeValueMalformed"] = "DEC_TIME_MALFORMED";
-  ULIDErrorCode2["EncodeTimeNegative"] = "ENC_TIME_NEG";
-  ULIDErrorCode2["EncodeTimeSizeExceeded"] = "ENC_TIME_SIZE_EXCEED";
-  ULIDErrorCode2["EncodeTimeValueMalformed"] = "ENC_TIME_MALFORMED";
-  ULIDErrorCode2["PRNGDetectFailure"] = "PRNG_DETECT";
-  ULIDErrorCode2["ULIDInvalid"] = "ULID_INVALID";
-  ULIDErrorCode2["Unexpected"] = "UNEXPECTED";
-  ULIDErrorCode2["UUIDInvalid"] = "UUID_INVALID";
-})(ULIDErrorCode || (ULIDErrorCode = {}));
-var ULIDError = class extends Error {
-  static {
-    __name(this, "ULIDError");
-  }
-  constructor(errorCode, message) {
-    super(`${message} (${errorCode})`);
-    this.name = "ULIDError";
-    this.code = errorCode;
-  }
-};
-function randomChar(prng) {
-  const randomPosition = Math.floor(prng() * ENCODING_LEN) % ENCODING_LEN;
-  return ENCODING.charAt(randomPosition);
-}
-__name(randomChar, "randomChar");
-function replaceCharAt(str, index, char) {
-  if (index > str.length - 1) {
-    return str;
-  }
-  return str.substr(0, index) + char + str.substr(index + 1);
-}
-__name(replaceCharAt, "replaceCharAt");
-function incrementBase32(str) {
-  let done = void 0, index = str.length, char, charIndex, output = str;
-  const maxCharIndex = ENCODING_LEN - 1;
-  while (!done && index-- >= 0) {
-    char = output[index];
-    charIndex = ENCODING.indexOf(char);
-    if (charIndex === -1) {
-      throw new ULIDError(ULIDErrorCode.Base32IncorrectEncoding, "Incorrectly encoded string");
-    }
-    if (charIndex === maxCharIndex) {
-      output = replaceCharAt(output, index, ENCODING[0]);
-      continue;
-    }
-    done = replaceCharAt(output, index, ENCODING[charIndex + 1]);
-  }
-  if (typeof done === "string") {
-    return done;
-  }
-  throw new ULIDError(ULIDErrorCode.Base32IncorrectEncoding, "Failed incrementing string");
-}
-__name(incrementBase32, "incrementBase32");
-function decodeTime(id) {
-  if (id.length !== TIME_LEN + RANDOM_LEN) {
-    throw new ULIDError(ULIDErrorCode.DecodeTimeValueMalformed, "Malformed ULID");
-  }
-  const time3 = id.substr(0, TIME_LEN).toUpperCase().split("").reverse().reduce((carry, char, index) => {
-    const encodingIndex = ENCODING.indexOf(char);
-    if (encodingIndex === -1) {
-      throw new ULIDError(ULIDErrorCode.DecodeTimeInvalidCharacter, `Time decode error: Invalid character: ${char}`);
-    }
-    return carry += encodingIndex * Math.pow(ENCODING_LEN, index);
-  }, 0);
-  if (time3 > TIME_MAX) {
-    throw new ULIDError(ULIDErrorCode.DecodeTimeValueMalformed, `Malformed ULID: timestamp too large: ${time3}`);
-  }
-  return time3;
-}
-__name(decodeTime, "decodeTime");
-function detectPRNG(root) {
-  const rootLookup = detectRoot();
-  const globalCrypto = rootLookup && (rootLookup.crypto || rootLookup.msCrypto) || (typeof import_node_crypto.default !== "undefined" ? import_node_crypto.default : null);
-  if (typeof globalCrypto?.getRandomValues === "function") {
-    return () => {
-      const buffer = new Uint8Array(1);
-      globalCrypto.getRandomValues(buffer);
-      return buffer[0] / 255;
-    };
-  } else if (typeof globalCrypto?.randomBytes === "function") {
-    return () => globalCrypto.randomBytes(1).readUInt8() / 255;
-  } else if (import_node_crypto.default?.randomBytes) {
-    return () => import_node_crypto.default.randomBytes(1).readUInt8() / 255;
-  }
-  throw new ULIDError(ULIDErrorCode.PRNGDetectFailure, "Failed to find a reliable PRNG");
-}
-__name(detectPRNG, "detectPRNG");
-function detectRoot() {
-  if (inWebWorker())
-    return self;
-  if (typeof window !== "undefined") {
-    return window;
-  }
-  if (typeof global !== "undefined") {
-    return global;
-  }
-  if (typeof globalThis !== "undefined") {
-    return globalThis;
-  }
-  return null;
-}
-__name(detectRoot, "detectRoot");
-function encodeRandom(len, prng) {
-  let str = "";
-  for (; len > 0; len--) {
-    str = randomChar(prng) + str;
-  }
-  return str;
-}
-__name(encodeRandom, "encodeRandom");
-function encodeTime(now, len = TIME_LEN) {
-  if (isNaN(now)) {
-    throw new ULIDError(ULIDErrorCode.EncodeTimeValueMalformed, `Time must be a number: ${now}`);
-  } else if (now > TIME_MAX) {
-    throw new ULIDError(ULIDErrorCode.EncodeTimeSizeExceeded, `Cannot encode a time larger than ${TIME_MAX}: ${now}`);
-  } else if (now < 0) {
-    throw new ULIDError(ULIDErrorCode.EncodeTimeNegative, `Time must be positive: ${now}`);
-  } else if (Number.isInteger(now) === false) {
-    throw new ULIDError(ULIDErrorCode.EncodeTimeValueMalformed, `Time must be an integer: ${now}`);
-  }
-  let mod, str = "";
-  for (let currentLen = len; currentLen > 0; currentLen--) {
-    mod = now % ENCODING_LEN;
-    str = ENCODING.charAt(mod) + str;
-    now = (now - mod) / ENCODING_LEN;
-  }
-  return str;
-}
-__name(encodeTime, "encodeTime");
-function inWebWorker() {
-  return typeof WorkerGlobalScope !== "undefined" && self instanceof WorkerGlobalScope;
-}
-__name(inWebWorker, "inWebWorker");
-function monotonicFactory(prng) {
-  const currentPRNG = prng || detectPRNG();
-  let lastTime = 0, lastRandom;
-  return /* @__PURE__ */ __name(function _ulid2(seedTime) {
-    const seed = !seedTime || isNaN(seedTime) ? Date.now() : seedTime;
-    if (seed <= lastTime) {
-      const incrementedRandom = lastRandom = incrementBase32(lastRandom);
-      return encodeTime(lastTime, TIME_LEN) + incrementedRandom;
-    }
-    lastTime = seed;
-    const newRandom = lastRandom = encodeRandom(RANDOM_LEN, currentPRNG);
-    return encodeTime(seed, TIME_LEN) + newRandom;
-  }, "_ulid");
-}
-__name(monotonicFactory, "monotonicFactory");
-
 // ../core/dist/runtime/world.js
 var import_node_module = require("node:module");
 var import_node_path9 = require("node:path");
 
+// ../world-local/dist/index.js
+var import_promises4 = require("node:fs/promises");
+
 // ../utils/dist/get-port.js
 var import_node_child_process = require("node:child_process");
 var import_promises = require("node:fs/promises");
@@ -48982,6 +49013,7 @@ function createQueue(config3) {
   const generateId2 = monotonicFactory();
   const semaphore = new import_async_sema.Sema(WORKFLOW_LOCAL_QUEUE_CONCURRENCY);
   const inflightMessages = /* @__PURE__ */ new Map();
+  const directHandlers = /* @__PURE__ */ new Map();
   const queue = /* @__PURE__ */ __name(async (queueName, message, opts) => {
     const cleanup = [];
     if (opts?.idempotencyKey) {
@@ -48992,10 +49024,13 @@ function createQueue(config3) {
     }
     const body = transport.serialize(message);
     let pathname;
+    let prefix;
     if (queueName.startsWith("__wkf_step_")) {
       pathname = `step`;
+      prefix = "__wkf_step_";
     } else if (queueName.startsWith("__wkf_workflow_")) {
       pathname = `flow`;
+      prefix = "__wkf_workflow_";
     } else {
       throw new Error("Unknown queue name prefix");
     }
@@ -49015,22 +49050,34 @@ function createQueue(config3) {
       }
       try {
         let defaultRetriesLeft = 3;
-        const baseUrl = await resolveBaseUrl(config3);
+        const directHandler = directHandlers.get(prefix);
         for (let attempt = 0; defaultRetriesLeft > 0; attempt++) {
           defaultRetriesLeft--;
-          const response = await fetch(`${baseUrl}/.well-known/workflow/v1/${pathname}`, {
-            method: "POST",
-            duplex: "half",
-            dispatcher: httpAgent,
-            headers: {
-              ...opts?.headers,
-              "content-type": "application/json",
-              "x-vqs-queue-name": queueName,
-              "x-vqs-message-id": messageId,
-              "x-vqs-message-attempt": String(attempt + 1)
-            },
-            body
-          });
+          let response;
+          const headers = {
+            ...opts?.headers,
+            "content-type": "application/json",
+            "x-vqs-queue-name": queueName,
+            "x-vqs-message-id": messageId,
+            "x-vqs-message-attempt": String(attempt + 1)
+          };
+          if (directHandler) {
+            const req = new Request("http://localhost/.well-known/workflow/v1/" + pathname, {
+              method: "POST",
+              headers,
+              body
+            });
+            response = await directHandler(req);
+          } else {
+            const baseUrl = await resolveBaseUrl(config3);
+            response = await fetch(`${baseUrl}/.well-known/workflow/v1/${pathname}`, {
+              method: "POST",
+              duplex: "half",
+              dispatcher: httpAgent,
+              headers,
+              body
+            });
+          }
           if (response.ok) {
             return;
           }
@@ -49112,6 +49159,9 @@ function createQueue(config3) {
     queue,
     createQueueHandler,
     getDeploymentId,
+    registerHandler(prefix, handler) {
+      directHandlers.set(prefix, handler);
+    },
     async close() {
       await httpAgent.close();
     }
@@ -49232,7 +49282,6 @@ var import_node_path5 = __toESM(require("node:path"), 1);
 var import_node_fs = require("node:fs");
 var import_node_path2 = __toESM(require("node:path"), 1);
 var ulid3 = monotonicFactory(() => Math.random());
-var Ulid = external_exports.string().ulid();
 var isWindows = process.platform === "win32";
 async function withWindowsRetry(fn, maxRetries = 5) {
   if (!isWindows)
@@ -49254,14 +49303,6 @@ async function withWindowsRetry(fn, maxRetries = 5) {
 }
 __name(withWindowsRetry, "withWindowsRetry");
 var createdFilesCache = /* @__PURE__ */ new Set();
-function ulidToDate(maybeUlid) {
-  const ulid5 = Ulid.safeParse(maybeUlid);
-  if (!ulid5.success) {
-    return null;
-  }
-  return new Date(decodeTime(ulid5.data));
-}
-__name(ulidToDate, "ulidToDate");
 async function ensureDir(dirPath) {
   try {
     await import_node_fs.promises.mkdir(dirPath, { recursive: true });
@@ -49672,6 +49713,12 @@ function createEventsStorage(basedir) {
       } else {
         effectiveRunId = runId;
       }
+      if (data.eventType === "run_created" && runId && runId !== "") {
+        const validationError = validateUlidTimestamp(effectiveRunId, "wrun_");
+        if (validationError) {
+          throw new WorkflowAPIError(validationError, { status: 400 });
+        }
+      }
       const effectiveSpecVersion = data.specVersion ?? SPEC_VERSION_CURRENT;
       const isRunTerminal = /* @__PURE__ */ __name((status) => ["completed", "failed", "cancelled"].includes(status), "isRunTerminal");
       const isStepTerminal = /* @__PURE__ */ __name((status) => ["completed", "failed"].includes(status), "isStepTerminal");
@@ -50486,6 +50533,10 @@ function createLocalWorld(args) {
     },
     async close() {
       await queue.close();
+    },
+    async clear() {
+      await (0, import_promises4.rm)(mergedConfig.dataDir, { recursive: true, force: true });
+      await initDataDir(mergedConfig.dataDir);
     }
   };
 }
@@ -53025,7 +53076,7 @@ var RpcService3 = SemanticConvention3("rpc.service");
 var RpcMethod3 = SemanticConvention3("rpc.method");
 
 // ../world-vercel/dist/version.js
-var version2 = "4.1.0-beta.38";
+var version2 = "4.1.0-beta.39";
 
 // ../world-vercel/dist/utils.js
 var WORKFLOW_SERVER_URL_OVERRIDE = "";
@@ -53885,6 +53936,12 @@ async function createWorkflowRunEvent(id, data, params, config3) {
     });
     return { event: wireResult2 };
   }
+  if (data.eventType === "run_created" && id) {
+    const validationError = validateUlidTimestamp(id, "wrun_");
+    if (validationError) {
+      throw new WorkflowAPIError(validationError, { status: 400 });
+    }
+  }
   const runIdPath = id === null ? "null" : id;
   const remoteRefBehavior = eventsNeedingResolve.has(data.eventType) ? "resolve" : "lazy";
   if (remoteRefBehavior === "resolve") {
@@ -58882,7 +58939,7 @@ function getWritable(options = {}) {
 __name(getWritable, "getWritable");
 
 // ../workflow/dist/stdlib.js
-var fetch = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//workflow@4.2.0-beta.64//fetch");
+var fetch = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//workflow@4.2.0-beta.65//fetch");
 
 // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/core.js
 var NEVER = Object.freeze({

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

@@ -3,18 +3,17 @@
     "steps": {
         "workflow/dist/stdlib.js": {
             "fetch": {
-                "stepId": "step//workflow@4.2.0-beta.64//fetch"
+                "stepId": "step//workflow@4.2.0-beta.65//fetch"
             }
         },
-        "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"
+        "workflows/hooks.ts": {
+            "writeEvent": {
+                "stepId": "step//./workflows/hooks//writeEvent"
+            }
+        },
+        "workflows/addition.ts": {
+            "add": {
+                "stepId": "step//./workflows/addition//add"
             }
         },
         "workflows/noop.ts": {
@@ -27,9 +26,15 @@
                 "stepId": "step//./workflows/null-byte//nullByteStep"
             }
         },
-        "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"
             }
         },
         "workflows/retriable-and-fatal.ts": {
@@ -39,24 +44,19 @@
             "stepThatThrowsRetryableError": {
                 "stepId": "step//./workflows/retriable-and-fatal//stepThatThrowsRetryableError"
             }
-        },
-        "workflows/hooks.ts": {
-            "writeEvent": {
-                "stepId": "step//./workflows/hooks//writeEvent"
-            }
         }
     },
     "workflows": {
-        "workflows/noop.ts": {
-            "brokenWf": {
-                "workflowId": "workflow//./workflows/noop//brokenWf",
+        "workflows/hooks.ts": {
+            "collectWithHook": {
+                "workflowId": "workflow//./workflows/hooks//collectWithHook",
                 "graph": {
                     "nodes": [
                         {
                             "id": "start",
                             "type": "workflowStart",
                             "data": {
-                                "label": "Start: brokenWf",
+                                "label": "Start: collectWithHook",
                                 "nodeKind": "workflow_start"
                             }
                         },
@@ -80,16 +80,16 @@
                 }
             }
         },
-        "workflows/null-byte.ts": {
-            "nullByteWorkflow": {
-                "workflowId": "workflow//./workflows/null-byte//nullByteWorkflow",
+        "workflows/addition.ts": {
+            "addition": {
+                "workflowId": "workflow//./workflows/addition//addition",
                 "graph": {
                     "nodes": [
                         {
                             "id": "start",
                             "type": "workflowStart",
                             "data": {
-                                "label": "Start: nullByteWorkflow",
+                                "label": "Start: addition",
                                 "nodeKind": "workflow_start"
                             }
                         },
@@ -113,16 +113,16 @@
                 }
             }
         },
-        "workflows/addition.ts": {
-            "addition": {
-                "workflowId": "workflow//./workflows/addition//addition",
+        "workflows/noop.ts": {
+            "brokenWf": {
+                "workflowId": "workflow//./workflows/noop//brokenWf",
                 "graph": {
                     "nodes": [
                         {
                             "id": "start",
                             "type": "workflowStart",
                             "data": {
-                                "label": "Start: addition",
+                                "label": "Start: brokenWf",
                                 "nodeKind": "workflow_start"
                             }
                         },
@@ -146,16 +146,16 @@
                 }
             }
         },
-        "workflows/retriable-and-fatal.ts": {
-            "retryableAndFatalErrorWorkflow": {
-                "workflowId": "workflow//./workflows/retriable-and-fatal//retryableAndFatalErrorWorkflow",
+        "workflows/null-byte.ts": {
+            "nullByteWorkflow": {
+                "workflowId": "workflow//./workflows/null-byte//nullByteWorkflow",
                 "graph": {
                     "nodes": [
                         {
                             "id": "start",
                             "type": "workflowStart",
                             "data": {
-                                "label": "Start: retryableAndFatalErrorWorkflow",
+                                "label": "Start: nullByteWorkflow",
                                 "nodeKind": "workflow_start"
                             }
                         },
@@ -179,16 +179,16 @@
                 }
             }
         },
-        "workflows/hooks.ts": {
-            "collectWithHook": {
-                "workflowId": "workflow//./workflows/hooks//collectWithHook",
+        "workflows/retriable-and-fatal.ts": {
+            "retryableAndFatalErrorWorkflow": {
+                "workflowId": "workflow//./workflows/retriable-and-fatal//retryableAndFatalErrorWorkflow",
                 "graph": {
                     "nodes": [
                         {
                             "id": "start",
                             "type": "workflowStart",
                             "data": {
-                                "label": "Start: collectWithHook",
+                                "label": "Start: retryableAndFatalErrorWorkflow",
                                 "nodeKind": "workflow_start"
                             }
                         },