@workflow/world-testing 5.0.0-beta.38 → 5.0.0-beta.39

package/dist/.well-known/workflow/v1/__step_registrations.mjs

@@ -380,7 +380,9 @@ function appendFramedDetails(title, details) {
     const head = isLast ? "\u2570\u25B6 " : "\u251C\u25B6 ";
     const cont = isLast ? "   " : "\u2502  ";
     const text = `${detail.label}: ${detail.value}`;
-    text.split("\n").forEach((line, i) => lines.push(`${i === 0 ? head : cont}${line}`));
+    text.split("\n").forEach((line, i) => {
+      lines.push(`${i === 0 ? head : cont}${line}`);
+    });
   });
   return lines.join("\n");
 }
@@ -12063,10 +12065,10 @@ function _property(property, schema, params) {
   });
 }
 // @__NO_SIDE_EFFECTS__
-function _mime(types2, params) {
+function _mime(types3, params) {
   return new $ZodCheckMimeType({
     check: "mime_type",
-    mime: types2,
+    mime: types3,
     ...normalizeParams(params)
   });
 }
@@ -15387,8 +15389,8 @@ var init_schemas2 = __esm({
       inst._zod.processJSONSchema = (ctx, json2, params) => fileProcessor(inst, ctx, json2, params);
       inst.min = (size, params) => inst.check(_minSize(size, params));
       inst.max = (size, params) => inst.check(_maxSize(size, params));
-      inst.mime = (types2, params) => inst.check(_mime(Array.isArray(types2) ? types2 : [
-        types2
+      inst.mime = (types3, params) => inst.check(_mime(Array.isArray(types3) ? types3 : [
+        types3
       ], params));
     });
     __name(file, "file");
@@ -16905,7 +16907,15 @@ var init_events = __esm({
       eventId: external_exports.string(),
       createdAt: external_exports.coerce.date(),
       occurredAt: external_exports.coerce.date().optional(),
-      specVersion: external_exports.number().optional()
+      specVersion: external_exports.number().optional(),
+      /**
+       * Lazy hook resume idempotency key, persisted on `hook_received` events so
+       * the queue consumer can detect that the producer's concurrent direct write
+       * already landed in the run_started preload and skip its own re-ensure.
+       * Mirrors {@link CreateEventParams.resumeId}; absent on all other events and
+       * on legacy (non-lazy) resumes.
+       */
+      resumeId: external_exports.string().optional()
     }));
   }
 });
@@ -17203,7 +17213,9 @@ var init_analytics = __esm({
       retryAfter: NullableDateSchema,
       errorCode: NullableStringSchema,
       workflowCoreVersion: NullableStringSchema,
-      workflowEncryptionEnabled: NullableBooleanSchema
+      workflowEncryptionEnabled: NullableBooleanSchema,
+      /** Compute instance of the latest attempt's `step_started`. */
+      computeInstanceId: NullableStringSchema
     });
     AnalyticsEventSchema = external_exports.object({
       runId: external_exports.string(),
@@ -17220,6 +17232,8 @@ var init_analytics = __esm({
       region: NullableStringSchema,
       vercelId: NullableStringSchema,
       requestId: NullableStringSchema,
+      /** Compute instance that wrote the event. See CreateEventParams. */
+      computeInstanceId: NullableStringSchema,
       resumeAt: NullableDateSchema,
       retryAfter: NullableDateSchema,
       errorCode: NullableStringSchema,
@@ -17333,7 +17347,7 @@ function getQueueTopicPrefix(kind, namespace) {
   }
   return "__wkf_workflow_";
 }
-var QueuePrefix, ValidQueueName, QueueNamespace, MessageId, TraceCarrierSchema, RunInputSchema, WorkflowInvokePayloadSchema, HealthCheckPayloadSchema, QueuePayloadSchema;
+var QueuePrefix, ValidQueueName, QueueNamespace, MessageId, TraceCarrierSchema, RunInputSchema, HookResumeInputSchema, WorkflowInvokePayloadSchema, HealthCheckPayloadSchema, QueuePayloadSchema;
 var init_queue = __esm({
   "../world/dist/queue.js"() {
     "use strict";
@@ -17358,7 +17372,50 @@ var init_queue = __esm({
        * `start()` option so resilient run creation validates the same way as
        * the original `run_created` attempt.
        */
-      allowReservedAttributes: external_exports.literal(true).optional()
+      allowReservedAttributes: external_exports.literal(true).optional(),
+      /**
+       * The environment the creating client's writes are attributed to, as
+       * reported by {@link World.getEnvironment} at `start()` time (on Vercel:
+       * `'production' | 'preview' | 'development'`).
+       *
+       * This exists so the resilient-start path can be checked for a tenant
+       * mismatch. `start()` writes `run_created` under the caller's own
+       * credentials while pinning the queue message to a deployment, and those
+       * two can disagree: if the message is consumed by a deployment in a
+       * DIFFERENT environment, that consumer's `run_started` re-creates the run
+       * under ITS tenant, so the same client-minted `wrun_` id ends up existing
+       * in two environments — one stuck pending forever, the other executing.
+       * Carrying the creator's environment lets the consumer compare it against
+       * its own and refuse the delivery instead of forking the run.
+       *
+       * Absent for worlds with no environment dimension (local, Postgres), and
+       * for older SDKs — consumers must treat it as advisory and skip the check
+       * when it is missing.
+       */
+      environment: external_exports.string().optional()
+    });
+    HookResumeInputSchema = external_exports.object({
+      /** Stable idempotency key minted once per `resumeHook()` call. */
+      resumeId: external_exports.string(),
+      /** The hook being resumed. */
+      hookId: external_exports.string(),
+      /**
+       * The hook's token, written into the `hook_received` event's `eventData` so
+       * the consumer's re-ensured event carries the same token the producer would
+       * — replay validates `eventData.token` against the `createHook` token.
+       */
+      token: external_exports.string(),
+      /** The serialized resume payload, reused verbatim from the direct write. */
+      payload: external_exports.unknown(),
+      /**
+       * Content digest of `payload`, computed once by the producer over the
+       * serialized bytes and forwarded verbatim on both the direct `events.create`
+       * and this queue message. The consumer forwards it back to the server so both
+       * writers of the same `resumeId` record an identical digest on the
+       * `(runId, resumeId)` constraint — required because the v4 payload ref is not
+       * content-stable server-side.
+       */
+      payloadDigest: external_exports.string()
     });
     WorkflowInvokePayloadSchema = external_exports.object({
       runId: external_exports.string(),
@@ -17369,6 +17426,14 @@ var init_queue = __esm({
         eventId: external_exports.string(),
         count: external_exports.number().int().positive()
       }).optional(),
+      /**
+       * Re-invocations so far in this chain of stale-snapshot (precondition)
+       * rejections. Counted on the message because the in-process restart budget
+       * lives in the invocation closure and the queue's delivery count resets on
+       * every fresh enqueue, so without this a permanently fenced run would cycle
+       * forever instead of failing.
+       */
+      preconditionReinvocations: external_exports.number().int().positive().optional(),
       /** Number of times this message has been re-enqueued due to server errors (5xx) */
       serverErrorRetryCount: external_exports.number().int().optional(),
       /** Step ID for inline step execution in combined handler. If provided, the flow execution
@@ -17377,7 +17442,13 @@ var init_queue = __esm({
       /** Step name, sent alongside stepId to avoid loading the event log just to resolve the name. */
       stepName: external_exports.string().optional(),
       /** Run creation data, only present on the first queue delivery from start() */
-      runInput: RunInputSchema.optional()
+      runInput: RunInputSchema.optional(),
+      /**
+       * Lazy hook resume data, only present when `resumeHook()` takes the parallel
+       * fast path. A consumer that understands this field idempotently ensures the
+       * `hook_received` event exists (keyed by `resumeId`) before replaying.
+       */
+      hookInput: HookResumeInputSchema.optional()
     });
     HealthCheckPayloadSchema = external_exports.object({
       __healthCheck: external_exports.literal(true),
@@ -17402,7 +17473,7 @@ var init_queue = __esm({
 });
 
 // ../world/dist/hooks.js
-var HookResumeContextSchema, HookSchema;
+var HookResumeContextSchema, HOOK_RESUME_INPUT_VERSION, HOOK_RESUME_DEDUP_VERSION, HookResumeCapabilitiesSchema, HookSchema;
 var init_hooks = __esm({
   "../world/dist/hooks.js"() {
     "use strict";
@@ -17421,7 +17492,25 @@ var init_hooks = __esm({
       // the run or fetching its symmetric key. Absent on runs created before
       // sealed envelopes and on projects with encryption disabled, where the
       // resume falls back to the symmetric per-run key.
-      encryptionPublicKey: external_exports.string().optional()
+      encryptionPublicKey: external_exports.string().optional(),
+      // Feature marker: the version of the lazy-hook-resume consumer protocol the
+      // run's creating deployment supports. Present (>= 1) means that deployment's
+      // `@workflow/core` re-ensures the `hook_received` event from the queue
+      // message's `hookInput` on replay, so `resumeHook()`'s parallel fast path is
+      // safe to use. Because a run is pinned to its creating deployment, this
+      // marker is a reliable per-run attestation — unlike inferring support from a
+      // version compare against a predicted release cutoff. Absent on runs created
+      // before the marker existed (fall back to the sequential path).
+      hookResumeInputVersion: external_exports.number().optional()
+    });
+    HOOK_RESUME_INPUT_VERSION = 1;
+    HOOK_RESUME_DEDUP_VERSION = 1;
+    HookResumeCapabilitiesSchema = external_exports.object({
+      // Present (>= HOOK_RESUME_DEDUP_VERSION) when the live backend enforces the
+      // `(runId, resumeId)` dedup constraint AND no server-side kill switch is
+      // active. Absent against an older/rolled-back server or when the kill switch
+      // is engaged.
+      hookResumeDedupVersion: external_exports.number()
     });
     HookSchema = external_exports.object({
       runId: external_exports.string(),
@@ -17439,7 +17528,15 @@ var init_hooks = __esm({
       // Present when the server stored it (new hooks) or synthesized it from the
       // run (old hooks). Absent only against an old server, where the resume path
       // falls back to `runs.get`.
-      resumeContext: HookResumeContextSchema.optional()
+      resumeContext: HookResumeContextSchema.optional(),
+      // Backend dedup capability, computed FRESH by the server on every by-token
+      // lookup — RESPONSE-ONLY and TRANSIENT. Never persisted on the hook entity
+      // and never part of `resumeContext`, so a server rollback or kill switch
+      // takes effect on the very next lookup (the field simply stops appearing).
+      // `resumeHook()` gates its parallel fast path on this being present and
+      // current. Absent against an older/rolled-back server or when the kill switch
+      // is active.
+      resumeCapabilities: HookResumeCapabilitiesSchema.optional()
     });
   }
 });
@@ -17501,7 +17598,7 @@ var init_spec_version = __esm({
 });
 
 // ../../node_modules/.pnpm/ulid@3.0.1/node_modules/ulid/dist/node/index.js
-import crypto from "node:crypto";
+import crypto2 from "node:crypto";
 function randomChar(prng) {
   const randomPosition = Math.floor(prng() * ENCODING_LEN) % ENCODING_LEN;
   return ENCODING.charAt(randomPosition);
@@ -17534,7 +17631,7 @@ function incrementBase32(str) {
 }
 function detectPRNG(root) {
   const rootLookup = detectRoot();
-  const globalCrypto = rootLookup && (rootLookup.crypto || rootLookup.msCrypto) || (typeof crypto !== "undefined" ? crypto : null);
+  const globalCrypto = rootLookup && (rootLookup.crypto || rootLookup.msCrypto) || (typeof crypto2 !== "undefined" ? crypto2 : null);
   if (typeof globalCrypto?.getRandomValues === "function") {
     return () => {
       const buffer2 = new Uint8Array(1);
@@ -17543,8 +17640,8 @@ function detectPRNG(root) {
     };
   } else if (typeof globalCrypto?.randomBytes === "function") {
     return () => globalCrypto.randomBytes(1).readUInt8() / 255;
-  } else if (crypto?.randomBytes) {
-    return () => crypto.randomBytes(1).readUInt8() / 255;
+  } else if (crypto2?.randomBytes) {
+    return () => crypto2.randomBytes(1).readUInt8() / 255;
   }
   throw new ULIDError(ULIDErrorCode.PRNGDetectFailure, "Failed to find a reliable PRNG");
 }
@@ -18345,10 +18442,10 @@ var init_encryption2 = __esm({
   }
 });
 
-// ../../node_modules/.pnpm/devalue@5.8.1/node_modules/devalue/src/constants.js
+// ../../node_modules/.pnpm/devalue@5.9.0/node_modules/devalue/src/constants.js
 var UNDEFINED, HOLE, NAN, POSITIVE_INFINITY, NEGATIVE_INFINITY, NEGATIVE_ZERO, SPARSE, MAX_ARRAY_LEN, MAX_ARRAY_INDEX;
 var init_constants = __esm({
-  "../../node_modules/.pnpm/devalue@5.8.1/node_modules/devalue/src/constants.js"() {
+  "../../node_modules/.pnpm/devalue@5.9.0/node_modules/devalue/src/constants.js"() {
     "use strict";
     UNDEFINED = -1;
     HOLE = -2;
@@ -18362,10 +18459,7 @@ var init_constants = __esm({
   }
 });
 
-// ../../node_modules/.pnpm/devalue@5.8.1/node_modules/devalue/src/utils.js
-function is_primitive(thing) {
-  return thing === null || typeof thing !== "object" && typeof thing !== "function";
-}
+// ../../node_modules/.pnpm/devalue@5.9.0/node_modules/devalue/src/utils.js
 function is_plain_object(thing) {
   const proto = Object.getPrototypeOf(thing);
   return proto === Object.prototype || proto === null || Object.getPrototypeOf(proto) === null || Object.getOwnPropertyNames(proto).sort().join("\0") === object_proto_names;
@@ -18440,19 +18534,22 @@ function is_valid_array_index_string(s) {
   }
   return is_valid_array_index(+s);
 }
-function valid_array_indices(array2) {
-  const keys = Object.keys(array2);
+function array_index_cut(keys) {
   for (var i = keys.length - 1; i >= 0; i--) {
     if (is_valid_array_index_string(keys[i])) {
       break;
     }
   }
-  keys.length = i + 1;
+  return i + 1;
+}
+function valid_array_indices(array2) {
+  const keys = Object.keys(array2);
+  keys.length = array_index_cut(keys);
   return keys;
 }
 var DevalueError, object_proto_names, is_identifier;
 var init_utils = __esm({
-  "../../node_modules/.pnpm/devalue@5.8.1/node_modules/devalue/src/utils.js"() {
+  "../../node_modules/.pnpm/devalue@5.9.0/node_modules/devalue/src/utils.js"() {
     "use strict";
     init_constants();
     DevalueError = class extends Error {
@@ -18473,7 +18570,6 @@ var init_utils = __esm({
         this.root = root;
       }
     };
-    __name(is_primitive, "is_primitive");
     object_proto_names = /* @__PURE__ */ Object.getOwnPropertyNames(Object.prototype).sort().join("\0");
     __name(is_plain_object, "is_plain_object");
     __name(get_type, "get_type");
@@ -18485,11 +18581,12 @@ var init_utils = __esm({
     __name(is_valid_array_index, "is_valid_array_index");
     __name(is_valid_array_len, "is_valid_array_len");
     __name(is_valid_array_index_string, "is_valid_array_index_string");
+    __name(array_index_cut, "array_index_cut");
     __name(valid_array_indices, "valid_array_indices");
   }
 });
 
-// ../../node_modules/.pnpm/devalue@5.8.1/node_modules/devalue/src/base64.js
+// ../../node_modules/.pnpm/devalue@5.9.0/node_modules/devalue/src/base64.js
 function encode_native(array_buffer) {
   return new Uint8Array(array_buffer).toBase64();
 }
@@ -18523,7 +18620,7 @@ function decode_legacy(base643) {
 }
 var native, buffer, encode64, decode64;
 var init_base64 = __esm({
-  "../../node_modules/.pnpm/devalue@5.8.1/node_modules/devalue/src/base64.js"() {
+  "../../node_modules/.pnpm/devalue@5.9.0/node_modules/devalue/src/base64.js"() {
     "use strict";
     __name(encode_native, "encode_native");
     __name(decode_native, "decode_native");
@@ -18538,11 +18635,119 @@ var init_base64 = __esm({
   }
 });
 
-// ../../node_modules/.pnpm/devalue@5.8.1/node_modules/devalue/src/parse.js
-function parse3(serialized, revivers) {
-  return unflatten(JSON.parse(serialized), revivers);
+// ../../node_modules/.pnpm/devalue@5.9.0/node_modules/devalue/src/operations.js
+function merge_operations(defaults, overrides) {
+  if (!overrides) return defaults;
+  const merged = (
+    /** @type {T} */
+    {}
+  );
+  for (const key of Object.keys(defaults)) {
+    merged[key] = overrides[key] ?? defaults[key];
+  }
+  return merged;
 }
-function unflatten(parsed, revivers) {
+var NOT_PLAIN, SYMBOL_KEYS, stringify_operations, default_stringify_operations, parse_operations, default_parse_operations;
+var init_operations = __esm({
+  "../../node_modules/.pnpm/devalue@5.9.0/node_modules/devalue/src/operations.js"() {
+    "use strict";
+    init_constants();
+    init_utils();
+    __name(merge_operations, "merge_operations");
+    NOT_PLAIN = Object.freeze({
+      kind: "not-plain"
+    });
+    SYMBOL_KEYS = Object.freeze({
+      kind: "symbol-keys"
+    });
+    stringify_operations = {
+      identify: /* @__PURE__ */ __name((value) => value, "identify"),
+      typeOf: /* @__PURE__ */ __name((value) => value === null ? "null" : typeof value, "typeOf"),
+      toPrimitive: /* @__PURE__ */ __name((value) => value, "toPrimitive"),
+      tagOf: /* @__PURE__ */ __name((value) => get_type(value), "tagOf"),
+      isThenable: /* @__PURE__ */ __name((value) => typeof value.then === "function", "isThenable"),
+      toPromise: /* @__PURE__ */ __name((thenable) => Promise.resolve(thenable), "toPromise"),
+      unbox: /* @__PURE__ */ __name((boxed) => boxed.valueOf(), "unbox"),
+      toISOString: /* @__PURE__ */ __name((date5) => isNaN(date5.getDate()) ? "" : date5.toISOString(), "toISOString"),
+      toStringValue: /* @__PURE__ */ __name((value) => value.toString(), "toStringValue"),
+      regExpInfo: /* @__PURE__ */ __name((regexp) => ({
+        source: regexp.source,
+        flags: regexp.flags
+      }), "regExpInfo"),
+      valuesOf: /* @__PURE__ */ __name((set2) => set2, "valuesOf"),
+      entriesOf: /* @__PURE__ */ __name((map2) => map2, "entriesOf"),
+      viewInfo: /* @__PURE__ */ __name((view) => ({
+        buffer: view.buffer,
+        byteOffset: view.byteOffset,
+        byteLength: view.byteLength,
+        length: view.length,
+        bufferByteLength: view.buffer.byteLength
+      }), "viewInfo"),
+      toArrayBuffer: /* @__PURE__ */ __name((buffer2) => buffer2, "toArrayBuffer"),
+      lengthOf: /* @__PURE__ */ __name((array2) => array2.length, "lengthOf"),
+      hasOwn: /* @__PURE__ */ __name((value, key) => Object.hasOwn(value, key), "hasOwn"),
+      indicesOf: /* @__PURE__ */ __name((array2) => valid_array_indices(array2), "indicesOf"),
+      shapeOf: /* @__PURE__ */ __name((value) => {
+        if (!is_plain_object(value)) return NOT_PLAIN;
+        if (enumerable_symbols(value).length > 0) return SYMBOL_KEYS;
+        return {
+          kind: Object.getPrototypeOf(value) === null ? "null-proto" : "plain",
+          keys: Object.keys(value)
+        };
+      }, "shapeOf"),
+      get: /* @__PURE__ */ __name((value, key) => value[key], "get")
+    };
+    default_stringify_operations = Object.freeze(stringify_operations);
+    parse_operations = {
+      fromPrimitive: /* @__PURE__ */ __name((primitive) => primitive, "fromPrimitive"),
+      fromISOString: /* @__PURE__ */ __name((iso) => new Date(iso), "fromISOString"),
+      fromStringValue: /* @__PURE__ */ __name((tag, text) => {
+        if (tag === "URL") return new URL(text);
+        if (tag === "URLSearchParams") return new URLSearchParams(text);
+        return Temporal[tag.slice(9)].from(text);
+      }, "fromStringValue"),
+      fromArrayBuffer: /* @__PURE__ */ __name((buffer2) => buffer2, "fromArrayBuffer"),
+      fromRegExpInfo: /* @__PURE__ */ __name((source, flags) => new RegExp(source, flags), "fromRegExpInfo"),
+      fromViewInfo: /* @__PURE__ */ __name((tag, buffer2, byteOffset, length) => {
+        const Constructor = (
+          /** @type {any} */
+          globalThis[tag]
+        );
+        return byteOffset !== void 0 ? new Constructor(buffer2, byteOffset, length) : new Constructor(buffer2);
+      }, "fromViewInfo"),
+      box: /* @__PURE__ */ __name((value) => Object(value), "box"),
+      createArray: /* @__PURE__ */ __name((length) => new Array(length), "createArray"),
+      createSparseArray: /* @__PURE__ */ __name((length) => {
+        const array2 = [];
+        array2[MAX_ARRAY_INDEX] = void 0;
+        delete array2[MAX_ARRAY_INDEX];
+        array2.length = length;
+        return array2;
+      }, "createSparseArray"),
+      createObject: /* @__PURE__ */ __name(() => ({}), "createObject"),
+      createNullPrototypeObject: /* @__PURE__ */ __name(() => /* @__PURE__ */ Object.create(null), "createNullPrototypeObject"),
+      createSet: /* @__PURE__ */ __name(() => /* @__PURE__ */ new Set(), "createSet"),
+      createMap: /* @__PURE__ */ __name(() => /* @__PURE__ */ new Map(), "createMap"),
+      set: /* @__PURE__ */ __name((target, key, value) => {
+        target[key] = value;
+      }, "set"),
+      addValue: /* @__PURE__ */ __name((set2, value) => {
+        set2.add(value);
+      }, "addValue"),
+      addEntry: /* @__PURE__ */ __name((map2, key, value) => {
+        map2.set(key, value);
+      }, "addEntry")
+    };
+    default_parse_operations = Object.freeze(parse_operations);
+  }
+});
+
+// ../../node_modules/.pnpm/devalue@5.9.0/node_modules/devalue/src/parse.js
+function parse3(serialized, revivers, options) {
+  return unflatten(JSON.parse(serialized), revivers, options);
+}
+function unflatten(parsed, revivers, options) {
+  const ops = merge_operations(default_parse_operations, options?.operations);
   if (typeof parsed === "number") return hydrate(parsed, true);
   if (!Array.isArray(parsed) || parsed.length === 0) {
     throw new Error("Invalid input");
@@ -18554,18 +18759,18 @@ function unflatten(parsed, revivers) {
   const hydrated = Array(values.length);
   let hydrating = null;
   function hydrate(index, standalone = false) {
-    if (index === UNDEFINED) return void 0;
-    if (index === NAN) return NaN;
-    if (index === POSITIVE_INFINITY) return Infinity;
-    if (index === NEGATIVE_INFINITY) return -Infinity;
-    if (index === NEGATIVE_ZERO) return -0;
+    if (index === UNDEFINED) return ops.fromPrimitive(void 0);
+    if (index === NAN) return ops.fromPrimitive(NaN);
+    if (index === POSITIVE_INFINITY) return ops.fromPrimitive(Infinity);
+    if (index === NEGATIVE_INFINITY) return ops.fromPrimitive(-Infinity);
+    if (index === NEGATIVE_ZERO) return ops.fromPrimitive(-0);
     if (standalone || typeof index !== "number") {
       throw new Error(`Invalid input`);
     }
     if (index in hydrated) return hydrated[index];
     const value = values[index];
     if (!value || typeof value !== "object") {
-      hydrated[index] = value;
+      hydrated[index] = ops.fromPrimitive(value);
     } else if (Array.isArray(value)) {
       if (typeof value[0] === "string") {
         const type = value[0];
@@ -18575,6 +18780,9 @@ function unflatten(parsed, revivers) {
           if (typeof i !== "number") {
             i = values.push(value[1]) - 1;
           }
+          if (Object.hasOwn(hydrated, i)) {
+            return hydrated[index] = reviver(hydrated[i]);
+          }
           hydrating ??= /* @__PURE__ */ new Set();
           if (hydrating.has(i)) {
             throw new Error("Invalid circular reference");
@@ -18586,44 +18794,44 @@ function unflatten(parsed, revivers) {
         }
         switch (type) {
           case "Date":
-            hydrated[index] = new Date(value[1]);
+            hydrated[index] = ops.fromISOString(value[1]);
             break;
           case "Set":
-            const set2 = /* @__PURE__ */ new Set();
+            const set2 = ops.createSet();
             hydrated[index] = set2;
             for (let i = 1; i < value.length; i += 1) {
-              set2.add(hydrate(value[i]));
+              ops.addValue(set2, hydrate(value[i]));
             }
             break;
           case "Map":
-            const map2 = /* @__PURE__ */ new Map();
+            const map2 = ops.createMap();
             hydrated[index] = map2;
             for (let i = 1; i < value.length; i += 2) {
-              map2.set(hydrate(value[i]), hydrate(value[i + 1]));
+              ops.addEntry(map2, hydrate(value[i]), hydrate(value[i + 1]));
             }
             break;
           case "RegExp":
-            hydrated[index] = new RegExp(value[1], value[2]);
+            hydrated[index] = ops.fromRegExpInfo(value[1], value[2]);
             break;
           case "Object": {
             const wrapped_index = value[1];
             if (typeof values[wrapped_index] === "object" && values[wrapped_index][0] !== "BigInt") {
               throw new Error("Invalid input");
             }
-            hydrated[index] = Object(hydrate(wrapped_index));
+            hydrated[index] = ops.box(hydrate(wrapped_index));
             break;
           }
           case "BigInt":
-            hydrated[index] = BigInt(value[1]);
+            hydrated[index] = ops.fromPrimitive(BigInt(value[1]));
             break;
           case "null":
-            const obj = /* @__PURE__ */ Object.create(null);
+            const obj = ops.createNullPrototypeObject();
             hydrated[index] = obj;
             for (let i = 1; i < value.length; i += 2) {
               if (value[i] === "__proto__") {
                 throw new Error("Cannot parse an object with a `__proto__` property");
               }
-              obj[value[i]] = hydrate(value[i + 1]);
+              ops.set(obj, value[i], hydrate(value[i + 1]));
             }
             break;
           case "Int8Array":
@@ -18642,9 +18850,8 @@ function unflatten(parsed, revivers) {
             if (values[value[1]][0] !== "ArrayBuffer") {
               throw new Error("Invalid data");
             }
-            const TypedArrayConstructor = globalThis[type];
             const buffer2 = hydrate(value[1]);
-            hydrated[index] = value[2] !== void 0 ? new TypedArrayConstructor(buffer2, value[2], value[3]) : new TypedArrayConstructor(buffer2);
+            hydrated[index] = ops.fromViewInfo(type, buffer2, value[2], value[3]);
             break;
           }
           case "ArrayBuffer": {
@@ -18652,10 +18859,11 @@ function unflatten(parsed, revivers) {
             if (typeof base643 !== "string") {
               throw new Error("Invalid ArrayBuffer encoding");
             }
-            const arraybuffer = decode64(base643);
-            hydrated[index] = arraybuffer;
+            hydrated[index] = ops.fromArrayBuffer(decode64(base643));
             break;
           }
+          case "URL":
+          case "URLSearchParams":
           case "Temporal.Duration":
           case "Temporal.Instant":
           case "Temporal.PlainDate":
@@ -18664,18 +18872,7 @@ function unflatten(parsed, revivers) {
           case "Temporal.PlainMonthDay":
           case "Temporal.PlainYearMonth":
           case "Temporal.ZonedDateTime": {
-            const temporalName = type.slice(9);
-            hydrated[index] = Temporal[temporalName].from(value[1]);
-            break;
-          }
-          case "URL": {
-            const url2 = new URL(value[1]);
-            hydrated[index] = url2;
-            break;
-          }
-          case "URLSearchParams": {
-            const url2 = new URLSearchParams(value[1]);
-            hydrated[index] = url2;
+            hydrated[index] = ops.fromStringValue(type, value[1]);
             break;
           }
           default:
@@ -18686,36 +18883,32 @@ function unflatten(parsed, revivers) {
         if (!is_valid_array_len(len)) {
           throw new Error("Invalid input");
         }
-        const array2 = [];
+        const array2 = ops.createSparseArray(len);
         hydrated[index] = array2;
-        array2[MAX_ARRAY_INDEX] = void 0;
-        delete array2[MAX_ARRAY_INDEX];
         for (let i = 2; i < value.length; i += 2) {
           const idx = value[i];
           if (!is_valid_array_index(idx) || idx >= len) {
             throw new Error("Invalid input");
           }
-          array2[idx] = hydrate(value[i + 1]);
+          ops.set(array2, idx, hydrate(value[i + 1]));
         }
-        array2.length = len;
       } else {
-        const array2 = new Array(value.length);
+        const array2 = ops.createArray(value.length);
         hydrated[index] = array2;
         for (let i = 0; i < value.length; i += 1) {
           const n = value[i];
           if (n === HOLE) continue;
-          array2[i] = hydrate(n);
+          ops.set(array2, i, hydrate(n));
         }
       }
     } else {
-      const object2 = {};
+      const object2 = ops.createObject();
       hydrated[index] = object2;
       for (const key of Object.keys(value)) {
         if (key === "__proto__") {
           throw new Error("Cannot parse an object with a `__proto__` property");
         }
-        const n = value[key];
-        object2[key] = hydrate(n);
+        ops.set(object2, key, hydrate(value[key]));
       }
     }
     return hydrated[index];
@@ -18724,22 +18917,24 @@ function unflatten(parsed, revivers) {
   return hydrate(0);
 }
 var init_parse3 = __esm({
-  "../../node_modules/.pnpm/devalue@5.8.1/node_modules/devalue/src/parse.js"() {
+  "../../node_modules/.pnpm/devalue@5.9.0/node_modules/devalue/src/parse.js"() {
     "use strict";
     init_base64();
     init_constants();
+    init_operations();
     init_utils();
     __name(parse3, "parse");
     __name(unflatten, "unflatten");
   }
 });
 
-// ../../node_modules/.pnpm/devalue@5.8.1/node_modules/devalue/src/stringify.js
-function stringify(value, reducers) {
-  const stringified = run(false, value, reducers);
+// ../../node_modules/.pnpm/devalue@5.9.0/node_modules/devalue/src/stringify.js
+function stringify(value, reducers, options) {
+  const stringified = run(false, value, reducers, options);
   return typeof stringified === "string" ? stringified : `[${stringified.join(",")}]`;
 }
-function run(async, value, reducers) {
+function run(async, value, reducers, options) {
+  const ops = merge_operations(default_stringify_operations, options?.operations);
   const stringified = [];
   const indexes = /* @__PURE__ */ new Map();
   const custom2 = [];
@@ -18754,17 +18949,24 @@ function run(async, value, reducers) {
   const keys = [];
   let p = 0;
   function flatten(thing, index2) {
-    if (thing === void 0) return UNDEFINED;
-    if (Number.isNaN(thing)) return NAN;
-    if (thing === Infinity) return POSITIVE_INFINITY;
-    if (thing === -Infinity) return NEGATIVE_INFINITY;
-    if (thing === 0 && 1 / thing < 0) return NEGATIVE_ZERO;
-    if (indexes.has(thing)) return (
+    const type = ops.typeOf(thing);
+    if (type === "undefined") return UNDEFINED;
+    let number4;
+    if (type === "number") {
+      number4 = /** @type {number} */
+      ops.toPrimitive(thing);
+      if (Number.isNaN(number4)) return NAN;
+      if (number4 === Infinity) return POSITIVE_INFINITY;
+      if (number4 === -Infinity) return NEGATIVE_INFINITY;
+      if (number4 === 0 && 1 / number4 < 0) return NEGATIVE_ZERO;
+    }
+    const id = ops.identify(thing);
+    if (indexes.has(id)) return (
       /** @type {number} */
-      indexes.get(thing)
+      indexes.get(id)
     );
     index2 ??= p++;
-    indexes.set(thing, index2);
+    indexes.set(id, index2);
     for (const { key, fn } of custom2) {
       const value2 = fn(thing);
       if (value2) {
@@ -18772,71 +18974,68 @@ function run(async, value, reducers) {
         return index2;
       }
     }
-    if (typeof thing === "function") {
+    if (type === "function") {
       throw new DevalueError(`Cannot stringify a function`, keys, thing, value);
-    } else if (typeof thing === "symbol") {
+    } else if (type === "symbol") {
       throw new DevalueError(`Cannot stringify a Symbol primitive`, keys, thing, value);
     }
     let str = "";
-    if (is_primitive(thing)) {
-      str = stringify_primitive(thing);
-    } else if (typeof thing.then === "function") {
+    if (type !== "object") {
+      str = stringify_primitive(type === "number" ? number4 : ops.toPrimitive(thing));
+    } else if (ops.isThenable(thing)) {
       if (!async) {
         throw new DevalueError(`Cannot stringify a Promise or thenable \u2014 use stringifyAsync instead`, keys, thing, value);
       }
-      str = Promise.resolve(thing).then((value2) => {
+      str = ops.toPromise(thing).then((value2) => {
         const i = flatten(value2, index2);
         if (i < 0) stringified[index2] = i;
       });
     } else {
-      const type = get_type(thing);
-      switch (type) {
+      const tag = ops.tagOf(thing);
+      switch (tag) {
         case "Number":
         case "String":
         case "Boolean":
         case "BigInt":
-          str = `["Object",${flatten(thing.valueOf())}]`;
+          str = `["Object",${flatten(ops.unbox(thing))}]`;
           break;
         case "Date":
-          const valid = !isNaN(thing.getDate());
-          str = `["Date","${valid ? thing.toISOString() : ""}"]`;
+          str = `["Date","${ops.toISOString(thing)}"]`;
           break;
         case "URL":
-          str = `["URL",${stringify_string(thing.toString())}]`;
+          str = `["URL",${stringify_string(ops.toStringValue(thing))}]`;
           break;
         case "URLSearchParams":
-          str = `["URLSearchParams",${stringify_string(thing.toString())}]`;
+          str = `["URLSearchParams",${stringify_string(ops.toStringValue(thing))}]`;
           break;
         case "RegExp":
-          const { source, flags } = thing;
+          const { source, flags } = ops.regExpInfo(thing);
           str = flags ? `["RegExp",${stringify_string(source)},"${flags}"]` : `["RegExp",${stringify_string(source)}]`;
           break;
         case "Array": {
           let mostly_dense = false;
+          const length = ops.lengthOf(thing);
           str = "[";
-          for (let i = 0; i < thing.length; i += 1) {
+          for (let i = 0; i < length; i += 1) {
             if (i > 0) str += ",";
-            if (Object.hasOwn(thing, i)) {
+            if (ops.hasOwn(thing, i)) {
               keys.push(`[${i}]`);
-              str += flatten(thing[i]);
+              str += flatten(ops.get(thing, i));
               keys.pop();
             } else if (mostly_dense) {
               str += HOLE;
             } else {
-              const populated_keys = valid_array_indices(
-                /** @type {any[]} */
-                thing
-              );
+              const populated_keys = ops.indicesOf(thing);
               const population = populated_keys.length;
-              const d = String(thing.length).length;
-              const hole_cost = (thing.length - population) * 3;
+              const d = String(length).length;
+              const hole_cost = (length - population) * 3;
               const sparse_cost = 4 + d + population * (d + 1);
               if (hole_cost > sparse_cost) {
-                str = "[" + SPARSE + "," + thing.length;
+                str = "[" + SPARSE + "," + length;
                 for (let j = 0; j < populated_keys.length; j++) {
                   const key = populated_keys[j];
                   keys.push(`[${key}]`);
-                  str += "," + key + "," + flatten(thing[key]);
+                  str += "," + key + "," + flatten(ops.get(thing, key));
                   keys.pop();
                 }
                 break;
@@ -18851,15 +19050,17 @@ function run(async, value, reducers) {
         }
         case "Set":
           str = '["Set"';
-          for (const value2 of thing) {
+          for (const value2 of ops.valuesOf(thing)) {
             str += `,${flatten(value2)}`;
           }
           str += "]";
           break;
         case "Map":
           str = '["Map"';
-          for (const [key, value2] of thing) {
-            keys.push(`.get(${is_primitive(key) ? stringify_primitive(key) : "..."})`);
+          for (const [key, value2] of ops.entriesOf(thing)) {
+            const key_type = ops.typeOf(key);
+            const key_is_primitive = key_type !== "object" && key_type !== "function" && key_type !== "symbol";
+            keys.push(`.get(${key_is_primitive ? stringify_primitive(ops.toPrimitive(key)) : "..."})`);
             str += `,${flatten(key)},${flatten(value2)}`;
             keys.pop();
           }
@@ -18876,19 +19077,26 @@ function run(async, value, reducers) {
         case "Float32Array":
         case "Float64Array":
         case "BigInt64Array":
-        case "BigUint64Array":
+        case "BigUint64Array": {
+          const info = ops.viewInfo(thing);
+          str = '["' + tag + '",' + flatten(info.buffer);
+          if (info.byteLength !== info.bufferByteLength) {
+            str += `,${info.byteOffset},${info.length}`;
+          }
+          str += "]";
+          break;
+        }
         case "DataView": {
-          const typedArray = thing;
-          str = '["' + type + '",' + flatten(typedArray.buffer);
-          if (typedArray.byteLength !== typedArray.buffer.byteLength) {
-            str += `,${typedArray.byteOffset},${typedArray.length}`;
+          const info = ops.viewInfo(thing);
+          str = '["' + tag + '",' + flatten(info.buffer);
+          if (info.byteLength !== info.bufferByteLength) {
+            str += `,${info.byteOffset},${info.byteLength}`;
           }
           str += "]";
           break;
         }
         case "ArrayBuffer": {
-          const arraybuffer = thing;
-          const base643 = encode64(arraybuffer);
+          const base643 = encode64(ops.toArrayBuffer(thing));
           str = `["ArrayBuffer","${base643}"]`;
           break;
         }
@@ -18900,41 +19108,43 @@ function run(async, value, reducers) {
         case "Temporal.PlainMonthDay":
         case "Temporal.PlainYearMonth":
         case "Temporal.ZonedDateTime":
-          str = `["${type}",${stringify_string(thing.toString())}]`;
+          str = `["${tag}",${stringify_string(ops.toStringValue(thing))}]`;
           break;
-        default:
-          if (!is_plain_object(thing)) {
+        default: {
+          const shape = ops.shapeOf(thing);
+          if (shape.kind === "not-plain") {
             throw new DevalueError(`Cannot stringify arbitrary non-POJOs`, keys, thing, value);
           }
-          if (enumerable_symbols(thing).length > 0) {
+          if (shape.kind === "symbol-keys") {
             throw new DevalueError(`Cannot stringify POJOs with symbolic keys`, keys, thing, value);
           }
-          if (Object.getPrototypeOf(thing) === null) {
+          if (shape.kind === "null-proto") {
             str = '["null"';
-            for (const key of Object.keys(thing)) {
+            for (const key of shape.keys) {
               if (key === "__proto__") {
                 throw new DevalueError(`Cannot stringify objects with __proto__ keys`, keys, thing, value);
               }
               keys.push(stringify_key(key));
-              str += `,${stringify_string(key)},${flatten(thing[key])}`;
+              str += `,${stringify_string(key)},${flatten(ops.get(thing, key))}`;
               keys.pop();
             }
             str += "]";
           } else {
             str = "{";
             let started = false;
-            for (const key of Object.keys(thing)) {
+            for (const key of shape.keys) {
               if (key === "__proto__") {
                 throw new DevalueError(`Cannot stringify objects with __proto__ keys`, keys, thing, value);
               }
               if (started) str += ",";
               started = true;
               keys.push(stringify_key(key));
-              str += `${stringify_string(key)}:${flatten(thing[key])}`;
+              str += `${stringify_string(key)}:${flatten(ops.get(thing, key))}`;
               keys.pop();
             }
             str += "}";
           }
+        }
       }
     }
     stringified[index2] = str;
@@ -18954,23 +19164,25 @@ function stringify_primitive(thing) {
   return String(thing);
 }
 var init_stringify = __esm({
-  "../../node_modules/.pnpm/devalue@5.8.1/node_modules/devalue/src/stringify.js"() {
+  "../../node_modules/.pnpm/devalue@5.9.0/node_modules/devalue/src/stringify.js"() {
     "use strict";
     init_utils();
     init_constants();
     init_base64();
+    init_operations();
     __name(stringify, "stringify");
     __name(run, "run");
     __name(stringify_primitive, "stringify_primitive");
   }
 });
 
-// ../../node_modules/.pnpm/devalue@5.8.1/node_modules/devalue/index.js
+// ../../node_modules/.pnpm/devalue@5.9.0/node_modules/devalue/index.js
 var init_devalue = __esm({
-  "../../node_modules/.pnpm/devalue@5.8.1/node_modules/devalue/index.js"() {
+  "../../node_modules/.pnpm/devalue@5.9.0/node_modules/devalue/index.js"() {
     "use strict";
     init_parse3();
     init_stringify();
+    init_operations();
     init_utils();
   }
 });
@@ -19315,6 +19527,326 @@ var init_get_world_lazy = __esm({
   }
 });
 
+// ../core/dist/serialization/hardened.js
+import { types } from "node:util";
+function withGuestCodeStats(stats, fn) {
+  const previousStats = activeStats;
+  const previousProxies = reportedProxies;
+  activeStats = stats ?? null;
+  reportedProxies = stats ? /* @__PURE__ */ new WeakSet() : null;
+  try {
+    return fn();
+  } finally {
+    activeStats = previousStats;
+    reportedProxies = previousProxies;
+  }
+}
+function isUseStepClosureFn(fn) {
+  return typeof fn === "function" && useStepClosureFns.has(fn);
+}
+function recordGuestCode(kind, detail) {
+  if (!activeStats) return;
+  const execution = {
+    kind
+  };
+  if (detail !== void 0) execution.detail = detail;
+  activeStats.executions.push(execution);
+}
+function recordProxy(value) {
+  if (!activeStats || !reportedProxies) return;
+  if (reportedProxies.has(value)) return;
+  reportedProxies.add(value);
+  recordGuestCode("proxy");
+}
+function protoGetter(prototype, key) {
+  const getter = Object.getOwnPropertyDescriptor(prototype, key)?.get;
+  if (!getter) {
+    throw new Error(`Missing intrinsic getter: ${String(key)}`);
+  }
+  return uncurryThis(getter);
+}
+function isEngineAccessor(getter) {
+  if (isProxy(getter)) return false;
+  const name = Object.getOwnPropertyDescriptor(getter, "name")?.value;
+  if (typeof name === "string" && name.startsWith("bound ")) return false;
+  return functionToString(getter).endsWith("{ [native code] }") || Reflect.getPrototypeOf(getter) === Function.prototype;
+}
+function readProperty(value, key) {
+  if (value === null || typeof value !== "object" && typeof value !== "function") {
+    return void 0;
+  }
+  if (isProxy(value)) {
+    recordProxy(value);
+    return value[key];
+  }
+  let current = value;
+  while (current !== null) {
+    if (isProxy(current)) {
+      recordProxy(current);
+      return value[key];
+    }
+    const descriptor = Object.getOwnPropertyDescriptor(current, key);
+    if (descriptor) {
+      if ("value" in descriptor) return descriptor.value;
+      if (descriptor.get) {
+        if (!isEngineAccessor(descriptor.get)) {
+          recordGuestCode("getter", String(key));
+        }
+        return descriptor.get.call(value);
+      }
+      return void 0;
+    }
+    current = Reflect.getPrototypeOf(current);
+  }
+  return void 0;
+}
+function hasProperty(value, key) {
+  if (value === null || typeof value !== "object" && typeof value !== "function") {
+    return false;
+  }
+  if (isProxy(value)) {
+    recordProxy(value);
+    return key in value;
+  }
+  let current = value;
+  while (current !== null) {
+    if (isProxy(current)) {
+      recordProxy(current);
+      return key in value;
+    }
+    if (Object.getOwnPropertyDescriptor(current, key)) return true;
+    current = Reflect.getPrototypeOf(current);
+  }
+  return false;
+}
+function isInstanceOfPrototype(value, prototype) {
+  if (!prototype) return false;
+  if (value === null || typeof value !== "object") return false;
+  if (isProxy(value)) recordProxy(value);
+  let current = Reflect.getPrototypeOf(value);
+  while (current !== null) {
+    if (current === prototype) return true;
+    if (isProxy(current)) recordProxy(current);
+    current = Reflect.getPrototypeOf(current);
+  }
+  return false;
+}
+function urlHref(value) {
+  if (isProxy(value)) {
+    recordProxy(value);
+    return value.href;
+  }
+  return urlHrefGetter(value);
+}
+function urlSearchParamsToString(value) {
+  if (isProxy(value)) {
+    recordProxy(value);
+    return String(value);
+  }
+  return urlSearchParamsToStringMethod(value);
+}
+function headersToEntries(value) {
+  if (isProxy(value)) {
+    recordProxy(value);
+    return Array.from(value);
+  }
+  return [
+    ...headersIterator(value)
+  ];
+}
+function mapToEntries(value) {
+  return [
+    ...mapEntries(value)
+  ];
+}
+function setToValues(value) {
+  return [
+    ...setValues(value)
+  ];
+}
+function viewInfo(value) {
+  if (types.isDataView(value)) {
+    return {
+      buffer: dataViewBuffer(value),
+      byteOffset: dataViewByteOffset(value),
+      byteLength: dataViewByteLength(value)
+    };
+  }
+  return {
+    buffer: typedArrayBuffer(value),
+    byteOffset: typedArrayByteOffset(value),
+    byteLength: typedArrayByteLength(value)
+  };
+}
+function brandOf(value) {
+  if (types.isDate(value)) return "Date";
+  if (types.isRegExp(value)) return "RegExp";
+  if (types.isMap(value)) return "Map";
+  if (types.isSet(value)) return "Set";
+  if (Array.isArray(value)) return "Array";
+  if (types.isTypedArray(value)) {
+    const tag = typedArrayTag(value);
+    return tag !== void 0 && KNOWN_VIEW_TAGS.has(tag) ? tag : void 0;
+  }
+  if (types.isDataView(value)) return "DataView";
+  if (types.isArrayBuffer(value)) return "ArrayBuffer";
+  if (types.isSharedArrayBuffer(value)) return "SharedArrayBuffer";
+  if (types.isNumberObject(value)) return "Number";
+  if (types.isStringObject(value)) return "String";
+  if (types.isBooleanObject(value)) return "Boolean";
+  if (types.isBigIntObject(value)) return "BigInt";
+  if (isInstanceOfPrototype(value, URL.prototype)) return "URL";
+  if (isInstanceOfPrototype(value, URLSearchParams.prototype)) {
+    return "URLSearchParams";
+  }
+  return void 0;
+}
+function readToStringTag(value) {
+  const tag = readProperty(value, Symbol.toStringTag);
+  return typeof tag === "string" ? tag : void 0;
+}
+var activeStats, reportedProxies, useStepClosureFns, uncurryThis, dateGetDate, dateGetTime, dateToISOString, regExpSource, regExpFlags, arrayBufferByteLength, mapEntries, setValues, numberValueOf, stringValueOf, booleanValueOf, bigIntValueOf, TypedArrayPrototype, typedArrayTag, typedArrayBuffer, typedArrayByteOffset, typedArrayByteLength, typedArrayLength, dataViewBuffer, dataViewByteOffset, dataViewByteLength, sharedArrayBufferByteLength, headersIterator, urlHrefGetter, urlSearchParamsToStringMethod, isProxy, functionToString, KNOWN_VIEW_TAGS, BRAND_DECIDED_TAGS, hardenedStringifyOperations;
+var init_hardened = __esm({
+  "../core/dist/serialization/hardened.js"() {
+    "use strict";
+    init_devalue();
+    activeStats = null;
+    reportedProxies = null;
+    __name(withGuestCodeStats, "withGuestCodeStats");
+    useStepClosureFns = /* @__PURE__ */ new WeakSet();
+    __name(isUseStepClosureFn, "isUseStepClosureFn");
+    __name(recordGuestCode, "recordGuestCode");
+    __name(recordProxy, "recordProxy");
+    uncurryThis = Function.prototype.bind.bind(Function.prototype.call);
+    __name(protoGetter, "protoGetter");
+    dateGetDate = uncurryThis(Date.prototype.getDate);
+    dateGetTime = uncurryThis(Date.prototype.getTime);
+    dateToISOString = uncurryThis(Date.prototype.toISOString);
+    regExpSource = protoGetter(RegExp.prototype, "source");
+    regExpFlags = protoGetter(RegExp.prototype, "flags");
+    arrayBufferByteLength = protoGetter(ArrayBuffer.prototype, "byteLength");
+    mapEntries = uncurryThis(Map.prototype.entries);
+    setValues = uncurryThis(Set.prototype.values);
+    numberValueOf = uncurryThis(Number.prototype.valueOf);
+    stringValueOf = uncurryThis(String.prototype.valueOf);
+    booleanValueOf = uncurryThis(Boolean.prototype.valueOf);
+    bigIntValueOf = uncurryThis(BigInt.prototype.valueOf);
+    TypedArrayPrototype = Object.getPrototypeOf(Uint8Array.prototype);
+    typedArrayTag = protoGetter(TypedArrayPrototype, Symbol.toStringTag);
+    typedArrayBuffer = protoGetter(TypedArrayPrototype, "buffer");
+    typedArrayByteOffset = protoGetter(TypedArrayPrototype, "byteOffset");
+    typedArrayByteLength = protoGetter(TypedArrayPrototype, "byteLength");
+    typedArrayLength = protoGetter(TypedArrayPrototype, "length");
+    dataViewBuffer = protoGetter(DataView.prototype, "buffer");
+    dataViewByteOffset = protoGetter(DataView.prototype, "byteOffset");
+    dataViewByteLength = protoGetter(DataView.prototype, "byteLength");
+    sharedArrayBufferByteLength = protoGetter(SharedArrayBuffer.prototype, "byteLength");
+    headersIterator = uncurryThis(Headers.prototype[Symbol.iterator]);
+    urlHrefGetter = protoGetter(URL.prototype, "href");
+    urlSearchParamsToStringMethod = uncurryThis(URLSearchParams.prototype.toString);
+    ({ isProxy } = types);
+    functionToString = uncurryThis(Function.prototype.toString);
+    __name(isEngineAccessor, "isEngineAccessor");
+    __name(readProperty, "readProperty");
+    __name(hasProperty, "hasProperty");
+    __name(isInstanceOfPrototype, "isInstanceOfPrototype");
+    __name(urlHref, "urlHref");
+    __name(urlSearchParamsToString, "urlSearchParamsToString");
+    __name(headersToEntries, "headersToEntries");
+    __name(mapToEntries, "mapToEntries");
+    __name(setToValues, "setToValues");
+    __name(viewInfo, "viewInfo");
+    KNOWN_VIEW_TAGS = /* @__PURE__ */ new Set([
+      "Int8Array",
+      "Uint8Array",
+      "Uint8ClampedArray",
+      "Int16Array",
+      "Uint16Array",
+      "Float16Array",
+      "Int32Array",
+      "Uint32Array",
+      "Float32Array",
+      "Float64Array",
+      "BigInt64Array",
+      "BigUint64Array"
+    ]);
+    BRAND_DECIDED_TAGS = /* @__PURE__ */ new Set([
+      "Date",
+      "RegExp",
+      "Map",
+      "Set",
+      "Array",
+      "DataView",
+      "ArrayBuffer",
+      "SharedArrayBuffer",
+      "Number",
+      "String",
+      "Boolean",
+      "BigInt",
+      "URL",
+      "URLSearchParams",
+      ...KNOWN_VIEW_TAGS
+    ]);
+    __name(brandOf, "brandOf");
+    __name(readToStringTag, "readToStringTag");
+    hardenedStringifyOperations = {
+      tagOf: /* @__PURE__ */ __name((value) => {
+        if (isProxy(value)) {
+          recordProxy(value);
+          return default_stringify_operations.tagOf(value);
+        }
+        const brand = brandOf(value);
+        if (brand !== void 0) return brand;
+        const tag = readToStringTag(value);
+        if (tag === void 0 || BRAND_DECIDED_TAGS.has(tag)) return "Object";
+        return tag;
+      }, "tagOf"),
+      isThenable: /* @__PURE__ */ __name((value) => {
+        if (types.isPromise(value)) return true;
+        return typeof readProperty(value, "then") === "function";
+      }, "isThenable"),
+      unbox: /* @__PURE__ */ __name((boxed) => {
+        if (types.isNumberObject(boxed)) return numberValueOf(boxed);
+        if (types.isStringObject(boxed)) return stringValueOf(boxed);
+        if (types.isBooleanObject(boxed)) return booleanValueOf(boxed);
+        return bigIntValueOf(boxed);
+      }, "unbox"),
+      toISOString: /* @__PURE__ */ __name((date5) => Number.isNaN(dateGetDate(date5)) ? "" : dateToISOString(date5), "toISOString"),
+      toStringValue: /* @__PURE__ */ __name((value) => {
+        if (isInstanceOfPrototype(value, URL.prototype)) {
+          return urlHref(value);
+        }
+        if (isInstanceOfPrototype(value, URLSearchParams.prototype)) {
+          return urlSearchParamsToString(value);
+        }
+        recordGuestCode("method", `toString (${readToStringTag(value) ?? "unknown"})`);
+        return value.toString();
+      }, "toStringValue"),
+      regExpInfo: /* @__PURE__ */ __name((regexp) => ({
+        source: regExpSource(regexp),
+        flags: regExpFlags(regexp)
+      }), "regExpInfo"),
+      valuesOf: /* @__PURE__ */ __name((set2) => setToValues(set2), "valuesOf"),
+      entriesOf: /* @__PURE__ */ __name((map2) => mapToEntries(map2), "entriesOf"),
+      viewInfo: /* @__PURE__ */ __name((view) => {
+        const info = viewInfo(view);
+        return {
+          ...info,
+          // devalue only reads `length` for typed-array subviews; DataView
+          // subviews are encoded from `byteLength`.
+          length: types.isDataView(view) ? 0 : typedArrayLength(view),
+          bufferByteLength: types.isSharedArrayBuffer(info.buffer) ? sharedArrayBufferByteLength(info.buffer) : arrayBufferByteLength(info.buffer)
+        };
+      }, "viewInfo"),
+      shapeOf: /* @__PURE__ */ __name((value) => {
+        if (isProxy(value)) recordProxy(value);
+        return default_stringify_operations.shapeOf(value);
+      }, "shapeOf"),
+      get: /* @__PURE__ */ __name((value, key) => readProperty(value, key), "get")
+    };
+  }
+});
+
 // ../core/dist/class-serialization.js
 function getRegistry(global2 = globalThis) {
   const g = global2;
@@ -19345,7 +19877,7 @@ function getClassReducers() {
     // over the generic Error serialization (devalue uses first-match-wins).
     Class: /* @__PURE__ */ __name((value) => {
       if (typeof value !== "function") return false;
-      const classId = value.classId;
+      const classId = readProperty(value, "classId");
       if (typeof classId !== "string") return false;
       return {
         classId
@@ -19353,14 +19885,15 @@ function getClassReducers() {
     }, "Class"),
     Instance: /* @__PURE__ */ __name((value) => {
       if (value === null || typeof value !== "object") return false;
-      const cls = value.constructor;
+      const cls = readProperty(value, "constructor");
       if (!cls || typeof cls !== "function") return false;
-      const serialize3 = cls[WORKFLOW_SERIALIZE];
+      const serialize3 = readProperty(cls, WORKFLOW_SERIALIZE);
       if (typeof serialize3 !== "function") return false;
-      const classId = cls.classId;
+      const classId = readProperty(cls, "classId");
       if (typeof classId !== "string") {
-        throw new Error(`Class "${cls.name}" with ${String(WORKFLOW_SERIALIZE)} must have a static "classId" property.`);
+        throw new Error(`Class "${String(readProperty(cls, "name"))}" with ${String(WORKFLOW_SERIALIZE)} must have a static "classId" property.`);
       }
+      recordGuestCode("method", `[WORKFLOW_SERIALIZE] (${classId})`);
       const data = serialize3.call(cls, value);
       return {
         classId,
@@ -19399,20 +19932,22 @@ var init_class = __esm({
     "use strict";
     init_dist3();
     init_class_serialization();
+    init_hardened();
     __name(getClassReducers, "getClassReducers");
     __name(getClassRevivers, "getClassRevivers");
   }
 });
 
 // ../core/dist/serialization/reducers/common.js
-import { types } from "node:util";
+import { types as types2 } from "node:util";
 function arrayBufferToBase64(value, offset, length) {
   if (length === 0) return ".";
   const uint8 = new Uint8Array(value, offset, length);
   return Buffer.from(uint8).toString("base64");
 }
 function viewToBase64(value) {
-  return arrayBufferToBase64(value.buffer, value.byteOffset, value.byteLength);
+  const info = viewInfo(value);
+  return arrayBufferToBase64(info.buffer, info.byteOffset, info.byteLength);
 }
 function reviveArrayBuffer(value, global2) {
   const base643 = value === "." ? "" : value;
@@ -19426,17 +19961,17 @@ function revive(str) {
   return JSON.parse(str);
 }
 function reduceErrorBase(value) {
-  if (!types.isNativeError(value)) return false;
+  if (!types2.isNativeError(value)) return false;
   const reduced = {
-    message: value.message,
-    stack: value.stack
+    message: readProperty(value, "message"),
+    stack: readProperty(value, "stack")
   };
-  if ("cause" in value) reduced.cause = value.cause;
+  if (hasProperty(value, "cause")) reduced.cause = readProperty(value, "cause");
   return reduced;
 }
 function reduceNamedErrorSubclassBase(subclassName, value) {
-  if (!types.isNativeError(value)) return false;
-  if (value.name !== subclassName) return false;
+  if (!types2.isNativeError(value)) return false;
+  if (readProperty(value, "name") !== subclassName) return false;
   return reduceErrorBase(value);
 }
 function makeErrorSubclassReducer(subclassName) {
@@ -19458,16 +19993,20 @@ function makeErrorSubclassReviver(global2, ctorName) {
     return error48;
   };
 }
-function getCommonReducers(global2 = globalThis) {
+function getCommonReducers(_global = globalThis) {
   return {
-    ArrayBuffer: /* @__PURE__ */ __name((value) => value instanceof global2.ArrayBuffer && arrayBufferToBase64(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"),
+    ArrayBuffer: /* @__PURE__ */ __name((value) => types2.isArrayBuffer(value) && arrayBufferToBase64(value, 0, arrayBufferByteLength(value)), "ArrayBuffer"),
+    BigInt: /* @__PURE__ */ __name((value) => (
+      // String(bigint) is a spec-internal numeric conversion — unlike
+      // `value.toString()`, it never consults BigInt.prototype.
+      typeof value === "bigint" && String(value)
+    ), "BigInt"),
+    BigInt64Array: /* @__PURE__ */ __name((value) => types2.isBigInt64Array(value) && viewToBase64(value), "BigInt64Array"),
+    BigUint64Array: /* @__PURE__ */ __name((value) => types2.isBigUint64Array(value) && viewToBase64(value), "BigUint64Array"),
     Date: /* @__PURE__ */ __name((value) => {
-      if (!(value instanceof global2.Date)) return false;
-      const valid = !Number.isNaN(value.getDate());
-      return valid ? value.toISOString() : ".";
+      if (!types2.isDate(value)) return false;
+      const valid = !Number.isNaN(dateGetDate(value));
+      return valid ? dateToISOString(value) : ".";
     }, "Date"),
     // DOMException is a special case: it `instanceof Error` is true in Node,
     // but `types.isNativeError()` returns FALSE for it, so the generic Error
@@ -19477,14 +20016,16 @@ function getCommonReducers(global2 = globalThis) {
     // for instances minted in another context).
     DOMException: /* @__PURE__ */ __name((value) => {
       if (value === null || typeof value !== "object") return false;
-      if (value.constructor?.name !== "DOMException") return false;
-      const e = value;
+      const ctor = readProperty(value, "constructor");
+      if (!ctor || readProperty(ctor, "name") !== "DOMException") return false;
       const reduced = {
-        message: e.message,
-        name: e.name,
-        stack: e.stack
+        message: readProperty(value, "message"),
+        name: readProperty(value, "name"),
+        stack: readProperty(value, "stack")
       };
-      if ("cause" in e) reduced.cause = e.cause;
+      if (hasProperty(value, "cause")) {
+        reduced.cause = readProperty(value, "cause");
+      }
       return reduced;
     }, "DOMException"),
     // Error subclass reducers are intentionally placed before the base Error
@@ -19497,13 +20038,13 @@ function getCommonReducers(global2 = globalThis) {
     HookConflictError: /* @__PURE__ */ __name((value) => {
       const base = reduceNamedErrorSubclassBase("HookConflictError", value);
       if (!base) return false;
-      const error48 = value;
       const reduced = {
         ...base,
-        token: error48.token
+        token: readProperty(value, "token")
       };
-      if (error48.conflictingRunId !== void 0) {
-        reduced.conflictingRunId = error48.conflictingRunId;
+      const conflictingRunId = readProperty(value, "conflictingRunId");
+      if (conflictingRunId !== void 0) {
+        reduced.conflictingRunId = conflictingRunId;
       }
       return reduced;
     }, "HookConflictError"),
@@ -19516,11 +20057,20 @@ function getCommonReducers(global2 = globalThis) {
     RetryableError: /* @__PURE__ */ __name((value) => {
       const base = reduceNamedErrorSubclassBase("RetryableError", value);
       if (!base) return false;
-      const retryAfterRaw = value.retryAfter;
+      const retryAfterRaw = readProperty(value, "retryAfter");
       let retryAfter;
-      if (retryAfterRaw && typeof retryAfterRaw === "object" && typeof retryAfterRaw.getTime === "function") {
-        const t = retryAfterRaw.getTime();
+      if (types2.isDate(retryAfterRaw)) {
+        const t = dateGetTime(retryAfterRaw);
         retryAfter = Number.isNaN(t) ? Date.now() + 1e3 : t;
+      } else if (retryAfterRaw && typeof retryAfterRaw === "object") {
+        const getTime = readProperty(retryAfterRaw, "getTime");
+        if (typeof getTime === "function") {
+          recordGuestCode("method", "getTime");
+          const t = getTime.call(retryAfterRaw);
+          retryAfter = Number.isNaN(t) ? Date.now() + 1e3 : t;
+        } else {
+          retryAfter = Date.now() + 1e3;
+        }
       } else if (typeof retryAfterRaw === "string" || typeof retryAfterRaw === "number") {
         const t = new Date(retryAfterRaw).getTime();
         retryAfter = Number.isNaN(t) ? Date.now() + 1e3 : t;
@@ -19541,7 +20091,7 @@ function getCommonReducers(global2 = globalThis) {
       const reduced = {
         ...base
       };
-      const context = value.context;
+      const context = readProperty(value, "context");
       if (context !== void 0) {
         reduced.context = context;
       }
@@ -19557,7 +20107,7 @@ function getCommonReducers(global2 = globalThis) {
       if (!base) return false;
       return {
         ...base,
-        errors: value.errors
+        errors: readProperty(value, "errors")
       };
     }, "AggregateError"),
     // Base Error reducer — catch-all for any Error instance not matched by a
@@ -19565,49 +20115,58 @@ function getCommonReducers(global2 = globalThis) {
     // WORKFLOW_SERIALIZE). Preserves `name` so the error's identity is retained
     // even though the exact class cannot be reconstructed.
     Error: /* @__PURE__ */ __name((value) => {
-      if (!types.isNativeError(value)) return false;
+      if (!types2.isNativeError(value)) return false;
       const reduced = {
-        name: value.name,
-        message: value.message,
-        stack: value.stack
+        name: readProperty(value, "name"),
+        message: readProperty(value, "message"),
+        stack: readProperty(value, "stack")
       };
-      if ("cause" in value) reduced.cause = value.cause;
+      if (hasProperty(value, "cause")) {
+        reduced.cause = readProperty(value, "cause");
+      }
       return reduced;
     }, "Error"),
-    Float32Array: /* @__PURE__ */ __name((value) => value instanceof global2.Float32Array && viewToBase64(value), "Float32Array"),
-    Float64Array: /* @__PURE__ */ __name((value) => value instanceof global2.Float64Array && viewToBase64(value), "Float64Array"),
-    Headers: /* @__PURE__ */ __name((value) => value instanceof global2.Headers && Array.from(value), "Headers"),
-    Int8Array: /* @__PURE__ */ __name((value) => value instanceof global2.Int8Array && viewToBase64(value), "Int8Array"),
-    Int16Array: /* @__PURE__ */ __name((value) => value instanceof global2.Int16Array && viewToBase64(value), "Int16Array"),
-    Int32Array: /* @__PURE__ */ __name((value) => value instanceof global2.Int32Array && viewToBase64(value), "Int32Array"),
-    Map: /* @__PURE__ */ __name((value) => value instanceof global2.Map && Array.from(value), "Map"),
-    RegExp: /* @__PURE__ */ __name((value) => value instanceof global2.RegExp && {
-      source: value.source,
-      flags: value.flags
+    Float32Array: /* @__PURE__ */ __name((value) => types2.isFloat32Array(value) && viewToBase64(value), "Float32Array"),
+    Float64Array: /* @__PURE__ */ __name((value) => types2.isFloat64Array(value) && viewToBase64(value), "Float64Array"),
+    // Headers is a host class injected into the sandbox, so its (shared)
+    // prototype is reachable from workflow code — iterate through the
+    // boot-captured iterator instead of a live Symbol.iterator lookup.
+    Headers: /* @__PURE__ */ __name((value) => isInstanceOfPrototype(value, Headers.prototype) && headersToEntries(value), "Headers"),
+    Int8Array: /* @__PURE__ */ __name((value) => types2.isInt8Array(value) && viewToBase64(value), "Int8Array"),
+    Int16Array: /* @__PURE__ */ __name((value) => types2.isInt16Array(value) && viewToBase64(value), "Int16Array"),
+    Int32Array: /* @__PURE__ */ __name((value) => types2.isInt32Array(value) && viewToBase64(value), "Int32Array"),
+    // Engine brand check + host-realm iteration: a patched
+    // `Map.prototype[Symbol.iterator]` in the sandbox is never consulted.
+    Map: /* @__PURE__ */ __name((value) => types2.isMap(value) && mapToEntries(value), "Map"),
+    RegExp: /* @__PURE__ */ __name((value) => types2.isRegExp(value) && {
+      source: regExpSource(value),
+      flags: regExpFlags(value)
     }, "RegExp"),
     // Request and Response are intentionally NOT in common reducers.
     // They require mode-specific revivers (stream handling, etc.) and
     // including them here without matching revivers would cause them
     // to deserialize as plain objects.
-    Set: /* @__PURE__ */ __name((value) => value instanceof global2.Set && Array.from(value), "Set"),
-    URL: /* @__PURE__ */ __name((value) => value instanceof global2.URL && value.href, "URL"),
+    Set: /* @__PURE__ */ __name((value) => types2.isSet(value) && setToValues(value), "Set"),
+    URL: /* @__PURE__ */ __name((value) => isInstanceOfPrototype(value, URL.prototype) && urlHref(value), "URL"),
     WorkflowFunction: /* @__PURE__ */ __name((value) => {
       if (typeof value !== "function") return false;
-      const workflowId = value.workflowId;
+      const workflowId = readProperty(value, "workflowId");
       if (typeof workflowId !== "string") return false;
       return {
         workflowId
       };
     }, "WorkflowFunction"),
     URLSearchParams: /* @__PURE__ */ __name((value) => {
-      if (!(value instanceof global2.URLSearchParams)) return false;
-      if (value.size === 0) return ".";
-      return String(value);
+      if (!isInstanceOfPrototype(value, URLSearchParams.prototype)) {
+        return false;
+      }
+      const text = urlSearchParamsToString(value);
+      return text === "" ? "." : text;
     }, "URLSearchParams"),
-    Uint8Array: /* @__PURE__ */ __name((value) => value instanceof global2.Uint8Array && viewToBase64(value), "Uint8Array"),
-    Uint8ClampedArray: /* @__PURE__ */ __name((value) => value instanceof global2.Uint8ClampedArray && viewToBase64(value), "Uint8ClampedArray"),
-    Uint16Array: /* @__PURE__ */ __name((value) => value instanceof global2.Uint16Array && viewToBase64(value), "Uint16Array"),
-    Uint32Array: /* @__PURE__ */ __name((value) => value instanceof global2.Uint32Array && viewToBase64(value), "Uint32Array")
+    Uint8Array: /* @__PURE__ */ __name((value) => types2.isUint8Array(value) && viewToBase64(value), "Uint8Array"),
+    Uint8ClampedArray: /* @__PURE__ */ __name((value) => types2.isUint8ClampedArray(value) && viewToBase64(value), "Uint8ClampedArray"),
+    Uint16Array: /* @__PURE__ */ __name((value) => types2.isUint16Array(value) && viewToBase64(value), "Uint16Array"),
+    Uint32Array: /* @__PURE__ */ __name((value) => types2.isUint32Array(value) && viewToBase64(value), "Uint32Array")
   };
 }
 function getCommonRevivers(global2 = globalThis) {
@@ -19719,6 +20278,7 @@ var init_common = __esm({
   "../core/dist/serialization/reducers/common.js"() {
     "use strict";
     init_dist2();
+    init_hardened();
     __name(arrayBufferToBase64, "arrayBufferToBase64");
     __name(viewToBase64, "viewToBase64");
     __name(reviveArrayBuffer, "reviveArrayBuffer");
@@ -19737,13 +20297,19 @@ function getStepFunctionReducer() {
   return {
     StepFunction: /* @__PURE__ */ __name((value) => {
       if (typeof value !== "function") return false;
-      const stepId = value.stepId;
+      const stepId = readProperty(value, "stepId");
       if (typeof stepId !== "string") return false;
-      const closureVarsFn = value.__closureVarsFn;
-      const closureVars = closureVarsFn && typeof closureVarsFn === "function" ? closureVarsFn() : void 0;
-      const hasBoundThis = "__boundThis" in value;
-      const boundThis = hasBoundThis ? value.__boundThis : void 0;
-      const boundArgs = value.__boundArgs;
+      const closureVarsFn = readProperty(value, "__closureVarsFn");
+      let closureVars;
+      if (typeof closureVarsFn === "function") {
+        if (!isUseStepClosureFn(closureVarsFn)) {
+          recordGuestCode("method", "__closureVarsFn");
+        }
+        closureVars = closureVarsFn();
+      }
+      const hasBoundThis = hasProperty(value, "__boundThis");
+      const boundThis = hasBoundThis ? readProperty(value, "__boundThis") : void 0;
+      const boundArgs = readProperty(value, "__boundArgs");
       const payload = {
         stepId
       };
@@ -19777,6 +20343,7 @@ function getStepFunctionReviver(global2 = globalThis) {
 var init_step_function = __esm({
   "../core/dist/serialization/reducers/step-function.js"() {
     "use strict";
+    init_hardened();
     __name(getStepFunctionReducer, "getStepFunctionReducer");
     __name(getStepFunctionReviver, "getStepFunctionReviver");
   }
@@ -19853,6 +20420,7 @@ var init_codec_devalue = __esm({
   "../core/dist/serialization/codec-devalue.js"() {
     "use strict";
     init_devalue();
+    init_hardened();
     init_class();
     init_common();
     init_step_function();
@@ -19865,7 +20433,9 @@ var init_codec_devalue = __esm({
       formatPrefix: SerializationFormat.DEVALUE_V1,
       serialize(value, mode, options) {
         const reducers = getReducersForMode(mode, options?.global, options?.extraReducers);
-        const str = stringify(value, reducers);
+        const str = withGuestCodeStats(options?.guestCodeStats, () => stringify(value, reducers, {
+          operations: hardenedStringifyOperations
+        }));
         return encoder.encode(str);
       },
       deserialize(data, mode, options) {
@@ -20396,7 +20966,7 @@ function SemanticConvention(...names) {
     value
   ]));
 }
-var WorkflowName, WorkflowOperation, WorkflowRunId, WorkflowRunStatus, WorkflowStartedAt, WorkflowEventsCount, WorkflowArgumentsCount, WorkflowResultType, WorkflowTracePropagated, WorkflowTraceMode, WorkflowTurbo, WorkflowErrorName, WorkflowErrorMessage, WorkflowErrorCode, WorkflowStepsCreated, WorkflowHooksCreated, WorkflowWaitsCreated, WorkflowOwnedRecoverySteps, WorkflowBackstopWakesArmed, WorkflowRouteType, WorkflowRouteHandlerCached, WorkflowRouteInvocationCount, WorkflowRouteEntrypointAgeMs, WorkflowRouteModuleBodyInitMs, StepName, StepId, StepAttempt, StepStatus, StepMaxRetries, StepTracePropagated, StepTtfsMs, StepStsoMs, StepRsfsMs, StepFinalSchedulingReplayMs, StepLatencyOptimizations, StepSkipped, StepSkipReason, StepArgumentsCount, StepResultType, StepErrorName, StepErrorMessage, StepFatalError, StepRetryExhausted, StepRetryTimeoutSeconds, StepRetryWillRetry, MessagingSystem, MessagingDestinationName, MessagingMessageId, MessagingOperationType, QueueOverheadMs, DeploymentId, HookToken, HookId, HookFound, WebhookHandlersTriggered, WorkflowSuspensionState, WorkflowSuspensionHookCount, WorkflowSuspensionStepCount, WorkflowSuspensionWaitCount, HttpRequestMethod, HttpRoute, UrlFull, ServerAddress, ServerPort, HttpResponseStatusCode, ErrorType, WorldParseFormat, WorkflowEventsPagesLoaded, QueueDeserializeTimeMs, QueueExecutionTimeMs, QueueSerializeTimeMs, SerializationOperation, SerializationCompressed, SerializationCodec, SerializationUncompressedBytes, SerializationStoredBytes, SerializationCompressionRatio, PeerService, RpcSystem, RpcService, RpcMethod, ErrorRetryable, ErrorCategory;
+var WorkflowName, WorkflowOperation, WorkflowRunId, WorkflowRunStatus, WorkflowStartedAt, WorkflowEventsCount, WorkflowArgumentsCount, WorkflowResultType, WorkflowTracePropagated, WorkflowTraceMode, WorkflowTurbo, WorkflowErrorName, WorkflowErrorMessage, WorkflowErrorCode, WorkflowStepsCreated, WorkflowHooksCreated, WorkflowWaitsCreated, WorkflowOwnedRecoverySteps, WorkflowBackstopWakesArmed, WorkflowRouteType, WorkflowRouteHandlerCached, WorkflowRouteInvocationCount, WorkflowRouteEntrypointAgeMs, WorkflowRouteModuleBodyInitMs, FaasInstance, StepName, StepId, StepAttempt, StepStatus, StepMaxRetries, StepTracePropagated, StepTtfsMs, StepStsoMs, StepRsfsMs, StepFinalSchedulingReplayMs, StepLatencyOptimizations, StepSkipped, StepSkipReason, StepArgumentsCount, StepResultType, StepErrorName, StepErrorMessage, StepFatalError, StepRetryExhausted, StepRetryTimeoutSeconds, StepRetryWillRetry, MessagingSystem, MessagingDestinationName, MessagingMessageId, MessagingOperationType, QueueOverheadMs, DeploymentId, HookToken, HookId, HookFound, HookResilientResume, HookResilientResumeMaterialized, WebhookHandlersTriggered, WorkflowSuspensionState, WorkflowSuspensionHookCount, WorkflowSuspensionStepCount, WorkflowSuspensionWaitCount, HttpRequestMethod, HttpRoute, UrlFull, ServerAddress, ServerPort, HttpResponseStatusCode, ErrorType, WorldParseFormat, WorkflowEventsPagesLoaded, QueueDeserializeTimeMs, QueueExecutionTimeMs, QueueSerializeTimeMs, SerializationOperation, SerializationCompressed, SerializationCodec, SerializationUncompressedBytes, SerializationStoredBytes, SerializationCompressionRatio, SerializationGuestCodeExecutions, SerializationGuestCodeDetails, PeerService, RpcSystem, RpcService, RpcMethod, ErrorRetryable, ErrorCategory;
 var init_semantic_conventions = __esm({
   "../core/dist/telemetry/semantic-conventions.js"() {
     "use strict";
@@ -20425,6 +20995,7 @@ var init_semantic_conventions = __esm({
     WorkflowRouteInvocationCount = SemanticConvention("workflow.route.invocation_count");
     WorkflowRouteEntrypointAgeMs = SemanticConvention("workflow.route.entrypoint_age_ms");
     WorkflowRouteModuleBodyInitMs = SemanticConvention("workflow.route.module_body_init_ms");
+    FaasInstance = SemanticConvention("faas.instance");
     StepName = SemanticConvention("step.name");
     StepId = SemanticConvention("step.id");
     StepAttempt = SemanticConvention("step.attempt");
@@ -20455,6 +21026,8 @@ var init_semantic_conventions = __esm({
     HookToken = SemanticConvention("workflow.hook.token");
     HookId = SemanticConvention("workflow.hook.id");
     HookFound = SemanticConvention("workflow.hook.found");
+    HookResilientResume = SemanticConvention("workflow.hook.resilient_resume");
+    HookResilientResumeMaterialized = SemanticConvention("workflow.hook.resilient_resume_materialized");
     WebhookHandlersTriggered = SemanticConvention("webhook.handlers.triggered");
     WorkflowSuspensionState = SemanticConvention("workflow.suspension.state");
     WorkflowSuspensionHookCount = SemanticConvention("workflow.suspension.hook_count");
@@ -20478,6 +21051,8 @@ var init_semantic_conventions = __esm({
     SerializationUncompressedBytes = SemanticConvention("workflow.serialization.uncompressed_bytes");
     SerializationStoredBytes = SemanticConvention("workflow.serialization.stored_bytes");
     SerializationCompressionRatio = SemanticConvention("workflow.serialization.compression_ratio");
+    SerializationGuestCodeExecutions = SemanticConvention("workflow.serialization.guest_code_executions");
+    SerializationGuestCodeDetails = SemanticConvention("workflow.serialization.guest_code_details");
     PeerService = SemanticConvention("peer.service");
     RpcSystem = SemanticConvention("rpc.system");
     RpcService = SemanticConvention("rpc.service");
@@ -22920,7 +23495,11 @@ var init_context_storage = __esm({
   "../core/dist/step/context-storage.js"() {
     "use strict";
     CONTEXT_STORAGE_SYMBOL = /* @__PURE__ */ Symbol.for("WORKFLOW_STEP_CONTEXT_STORAGE");
-    contextStorage = globalThis[CONTEXT_STORAGE_SYMBOL] ?? (globalThis[CONTEXT_STORAGE_SYMBOL] = new AsyncLocalStorage());
+    contextStorage = (() => {
+      const store = globalThis;
+      store[CONTEXT_STORAGE_SYMBOL] ??= new AsyncLocalStorage();
+      return store[CONTEXT_STORAGE_SYMBOL];
+    })();
   }
 });
 
@@ -25060,6 +25639,11 @@ var init_capabilities = __esm({
       }
     ];
     CAPABILITY_VERSION_TABLE = [
+      // TODO(release): verify this matches the actual version that ships byte-stream
+      // framing. If a "Version Packages (beta)" PR merges before this change, bump
+      // to the next beta. A too-low cutoff makes new producers write framed bytes to
+      // consumers that cannot unframe them (silent corruption); too-high merely
+      // delays the optimization (safe).
       {
         capability: "framedByteStreams",
         minVersion: "5.0.0-beta.15"
@@ -25072,12 +25656,53 @@ var init_capabilities = __esm({
   }
 });
 
+// ../core/dist/classify-error.js
+function isRetryableWorldError(err) {
+  if (ThrottleError.is(err)) {
+    return true;
+  }
+  if (!WorkflowWorldError.is(err)) {
+    return false;
+  }
+  if (err.status !== void 0 && err.status >= 500) {
+    return true;
+  }
+  return err.code !== void 0 && RETRYABLE_WORLD_ERROR_CODES.has(err.code);
+}
+var WORLD_CONTRACT_ERROR_CODES, RETRYABLE_WORLD_ERROR_CODES, RUNTIME_ERROR_CHECKS;
+var init_classify_error = __esm({
+  "../core/dist/classify-error.js"() {
+    "use strict";
+    init_dist2();
+    WORLD_CONTRACT_ERROR_CODES = /* @__PURE__ */ new Set([
+      "PARSE_ERROR",
+      "SCHEMA_VALIDATION",
+      RUN_ERROR_CODES.WORLD_CONTRACT_ERROR
+    ]);
+    RETRYABLE_WORLD_ERROR_CODES = /* @__PURE__ */ new Set([
+      "TRANSPORT",
+      "TIMEOUT"
+    ]);
+    RUNTIME_ERROR_CHECKS = [
+      WorkflowRuntimeError.is,
+      StepNotRegisteredError.is,
+      WorkflowNotRegisteredError.is,
+      // SDK-level encryption failures (most notably AES-GCM auth-tag
+      // mismatches surfacing as a native `OperationError` from
+      // `AESCipherJob.onDone`) are wrapped in `RuntimeDecryptionError` at
+      // the encryption module boundary.
+      RuntimeDecryptionError.is
+    ];
+    __name(isRetryableWorldError, "isRetryableWorldError");
+  }
+});
+
 // ../core/dist/version.js
 var version2;
 var init_version = __esm({
   "../core/dist/version.js"() {
     "use strict";
-    version2 = "5.0.0-beta.38";
+    version2 = "5.0.0-beta.39";
   }
 });
 
@@ -25166,6 +25791,9 @@ function parseHealthCheckResponse(chunks) {
   if (typeof r.encryptionPublicKey === "string") {
     parsed.encryptionPublicKey = r.encryptionPublicKey;
   }
+  if (typeof r.hookResumeInputVersion === "number") {
+    parsed.hookResumeInputVersion = r.hookResumeInputVersion;
+  }
   return parsed;
 }
 async function healthCheck(world, options) {
@@ -26425,16 +27053,27 @@ __export(resume_hook_exports, {
   resumeHook: () => resumeHook,
   resumeWebhook: () => resumeWebhook
 });
+async function computeResumePayloadDigest(bytes) {
+  const digest = await crypto.subtle.digest("SHA-256", bytes);
+  const view = new Uint8Array(digest);
+  let hex3 = "";
+  for (const b of view) {
+    hex3 += b.toString(16).padStart(2, "0");
+  }
+  return hex3;
+}
 function resumeContextFromRun(run2) {
   const coreVersion = run2.executionContext?.workflowCoreVersion;
   const traceCarrier = run2.executionContext?.traceCarrier;
+  const hookResumeInputVersion = run2.executionContext?.hookResumeInputVersion;
   return {
     deploymentId: run2.deploymentId,
     workflowName: run2.workflowName,
     runSpecVersion: run2.specVersion,
     workflowCoreVersion: typeof coreVersion === "string" ? coreVersion : void 0,
     traceCarrier: traceCarrier && typeof traceCarrier === "object" ? traceCarrier : void 0,
-    encryptionPublicKey: run2.encryptionPublicKey
+    encryptionPublicKey: run2.encryptionPublicKey,
+    hookResumeInputVersion: typeof hookResumeInputVersion === "number" ? hookResumeInputVersion : void 0
   };
 }
 async function resolveHookResumeInfo(hook) {
@@ -26480,11 +27119,16 @@ async function getHookByToken(token) {
   return hook;
 }
 async function resumeHook(tokenOrHook, payload, encryptionKeyOverride) {
+  return resumeHookImpl(tokenOrHook, payload, encryptionKeyOverride, false);
+}
+async function resumeHookImpl(tokenOrHook, payload, encryptionKeyOverride, hookFreshlyLookedUp) {
   return await waitedUntil(() => {
     return trace("hook.resume", async (span) => {
       const world = await getWorldLazy();
       try {
-        const hook = typeof tokenOrHook === "string" ? await world.hooks.getByToken(tokenOrHook) : tokenOrHook;
+        const suppliedToken = typeof tokenOrHook === "string";
+        const hook = suppliedToken ? await world.hooks.getByToken(tokenOrHook) : tokenOrHook;
+        const hookResumeCapabilitiesAreFresh = suppliedToken || hookFreshlyLookedUp;
         const info = await resolveHookResumeInfo(hook);
         const { resumeContext } = info;
         span?.setAttributes({
@@ -26524,26 +27168,6 @@ async function resumeHook(tokenOrHook, payload, encryptionKeyOverride) {
             error: err instanceof Error ? err.message : String(err)
           });
         });
-        try {
-          await world.events.create(hook.runId, {
-            eventType: "hook_received",
-            specVersion: SPEC_VERSION_CURRENT,
-            correlationId: hook.hookId,
-            eventData: {
-              ...v1Compat ? {} : {
-                token: hook.token
-              },
-              payload: dehydratedPayload
-            }
-          }, {
-            v1Compat
-          });
-        } catch (err) {
-          if (HookNotFoundError.is(err) || EntityConflictError.is(err) || RunExpiredError.is(err)) {
-            throw new HookNotFoundError(hook.token);
-          }
-          throw err;
-        }
         span?.setAttributes({
           ...WorkflowName(resumeContext.workflowName)
         });
@@ -26551,15 +27175,108 @@ async function resumeHook(tokenOrHook, payload, encryptionKeyOverride) {
         if (originLink) {
           span?.addLink?.(originLink);
         }
-        await world.queue(getWorkflowQueueName(resumeContext.workflowName), {
-          runId: hook.runId,
-          // attach the trace carrier from the run's resume context
-          traceCarrier: resumeContext.traceCarrier ?? void 0
-        }, {
+        const eventData = {
+          ...v1Compat ? {} : {
+            token: hook.token
+          },
+          payload: dehydratedPayload
+        };
+        const queueName = getWorkflowQueueName(resumeContext.workflowName);
+        const queueOptions = {
           deploymentId: resumeContext.deploymentId,
           specVersion: resumeContext.runSpecVersion ?? SPEC_VERSION_LEGACY
+        };
+        const parallelResumeDisabled = process.env.WORKFLOW_DISABLE_LAZY_HOOK_RESUME === "1";
+        const backendDedupSupported = (hookResumeCapabilitiesAreFresh ? hook.resumeCapabilities?.hookResumeDedupVersion ?? 0 : 0) >= HOOK_RESUME_DEDUP_VERSION || world.capabilities?.hookResumeDedup === true;
+        const fallbackReason = parallelResumeDisabled ? "disabled" : !backendDedupSupported ? "backend_unsupported" : (resumeContext.hookResumeInputVersion ?? 0) < HOOK_RESUME_INPUT_VERSION ? "consumer_unsupported" : v1Compat ? "legacy" : (resumeContext.runSpecVersion ?? 0) < SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT ? "non_cbor_transport" : !(dehydratedPayload instanceof Uint8Array) ? "non_bytes" : dehydratedPayload.byteLength > MAX_INLINE_RESUME_PAYLOAD_BYTES ? "oversized" : null;
+        const useParallelResume = fallbackReason === null;
+        span?.setAttributes({
+          "workflow.hook.resume_strategy": useParallelResume ? "parallel" : "sequential",
+          ...fallbackReason ? {
+            "workflow.hook.resume_fallback_reason": fallbackReason
+          } : {}
         });
-        return hook;
+        const isHookGoneError = /* @__PURE__ */ __name((err) => HookNotFoundError.is(err) || EntityConflictError.is(err) || RunExpiredError.is(err), "isHookGoneError");
+        if (!useParallelResume) {
+          try {
+            await world.events.create(hook.runId, {
+              eventType: "hook_received",
+              specVersion: SPEC_VERSION_CURRENT,
+              correlationId: hook.hookId,
+              eventData
+            }, {
+              v1Compat
+            });
+          } catch (err) {
+            if (isHookGoneError(err)) {
+              throw new HookNotFoundError(hook.token);
+            }
+            throw err;
+          }
+          await world.queue(queueName, {
+            runId: hook.runId,
+            traceCarrier: resumeContext.traceCarrier ?? void 0
+          }, queueOptions);
+          return hook;
+        }
+        const resumeId = generateResumeId();
+        const payloadDigest = await computeResumePayloadDigest(dehydratedPayload);
+        span?.setAttributes({
+          "workflow.hook.resume_id": resumeId
+        });
+        const [eventResult, queueResult] = await Promise.allSettled([
+          world.events.create(hook.runId, {
+            eventType: "hook_received",
+            specVersion: SPEC_VERSION_CURRENT,
+            correlationId: hook.hookId,
+            eventData
+          }, {
+            v1Compat,
+            resumeId,
+            resumePayloadDigest: payloadDigest
+          }),
+          world.queue(queueName, {
+            runId: hook.runId,
+            traceCarrier: resumeContext.traceCarrier ?? void 0,
+            hookInput: {
+              resumeId,
+              hookId: hook.hookId,
+              token: hook.token,
+              payload: dehydratedPayload,
+              payloadDigest
+            }
+          }, queueOptions)
+        ]);
+        if (queueResult.status === "rejected") {
+          throw queueResult.reason;
+        }
+        let resilientResume = false;
+        if (eventResult.status === "rejected") {
+          const err = eventResult.reason;
+          if (HookNotFoundError.is(err) || RunExpiredError.is(err)) {
+            throw new HookNotFoundError(hook.token);
+          }
+          if (EntityConflictError.is(err) || isRetryableWorldError(err)) {
+            resilientResume = true;
+            span?.setAttributes({
+              ...HookResilientResume(true),
+              "workflow.hook.resume_event_write_recovered": true,
+              "workflow.hook.resume_event_write_error": err instanceof Error ? err.name : "unknown"
+            });
+            runtimeLogger.warn("Hook resume event write failed, but the run was re-triggered via the queue. The hook_received event will be ensured by the queue consumer.", {
+              workflowRunId: hook.runId,
+              hookId: hook.hookId,
+              resumeId,
+              error: err instanceof Error ? err.message : String(err)
+            });
+          } else {
+            throw err;
+          }
+        }
+        return resilientResume ? {
+          ...hook,
+          resilientResume: true
+        } : hook;
       } catch (err) {
         span?.setAttributes({
           ...HookToken(typeof tokenOrHook === "string" ? tokenOrHook : tokenOrHook.token),
@@ -26594,7 +27311,7 @@ async function resumeWebhook(token, request) {
       status: 202
     });
   }
-  await resumeHook(hook, request, encryptionKey);
+  await resumeHookImpl(hook, request, encryptionKey, true);
   if (responseReadable) {
     const reader = responseReadable.getReader();
     const chunk = await reader.read();
@@ -26610,12 +27327,15 @@ async function resumeWebhook(token, request) {
   }
   return response;
 }
+var generateResumeId, MAX_INLINE_RESUME_PAYLOAD_BYTES;
 var init_resume_hook = __esm({
   "../core/dist/runtime/resume-hook.js"() {
     "use strict";
     init_dist2();
     init_dist4();
+    init_node();
     init_capabilities();
+    init_classify_error();
     init_encryption();
     init_logger();
     init_sealed_box();
@@ -26627,12 +27347,16 @@ var init_resume_hook = __esm({
     init_get_world_lazy();
     init_helpers();
     init_wait_until();
+    generateResumeId = monotonicFactory();
+    MAX_INLINE_RESUME_PAYLOAD_BYTES = 128 * 1024;
+    __name(computeResumePayloadDigest, "computeResumePayloadDigest");
     __name(resumeContextFromRun, "resumeContextFromRun");
     __name(resolveHookResumeInfo, "resolveHookResumeInfo");
     __name(resolveHookEncryptionKey, "resolveHookEncryptionKey");
     __name(getHookByTokenWithKey, "getHookByTokenWithKey");
     __name(getHookByToken, "getHookByToken");
     __name(resumeHook, "resumeHook");
+    __name(resumeHookImpl, "resumeHookImpl");
     __name(resumeWebhook, "resumeWebhook");
   }
 });
@@ -26676,6 +27400,21 @@ async function recordCompression(stats, operation) {
   } catch {
   }
 }
+async function recordGuestCodeExecutions(stats) {
+  if (stats.executions.length === 0) return;
+  try {
+    const span = await getActiveSpan();
+    if (!span) return;
+    const details = [
+      ...new Set(stats.executions.map((e) => e.detail ? `${e.kind} (${e.detail})` : e.kind))
+    ];
+    span.setAttributes({
+      ...SerializationGuestCodeExecutions(stats.executions.length),
+      ...SerializationGuestCodeDetails(details)
+    });
+  } catch {
+  }
+}
 function getSerializeStream(reducers, cryptoKey) {
   const encoder2 = new TextEncoder();
   const keyState = {
@@ -27066,33 +27805,34 @@ function getAllBaseReducers(global2 = globalThis) {
     // Request and Response reducers are mode-specific and added by
     // getExternalReducers / getWorkflowReducers / getStepReducers below.
     Request: /* @__PURE__ */ __name((value) => {
-      if (!(value instanceof global2.Request)) return false;
+      if (!isInstanceOfPrototype(value, getHostClassPrototype(global2, "Request"))) return false;
       const data = {
-        method: value.method,
-        url: value.url,
-        headers: value.headers,
-        body: value.body,
-        duplex: value.duplex
+        method: readProperty(value, "method"),
+        url: readProperty(value, "url"),
+        headers: readProperty(value, "headers"),
+        body: readProperty(value, "body"),
+        duplex: readProperty(value, "duplex")
       };
-      const responseWritable = value[WEBHOOK_RESPONSE_WRITABLE];
+      const responseWritable = readProperty(value, WEBHOOK_RESPONSE_WRITABLE);
       if (responseWritable) {
         data.responseWritable = responseWritable;
       }
-      if (value.signal && (value.signal.aborted || value.signal[ABORT_STREAM_NAME])) {
-        data.signal = value.signal;
+      const signal = readProperty(value, "signal");
+      if (signal && (readProperty(signal, "aborted") || readProperty(signal, ABORT_STREAM_NAME))) {
+        data.signal = signal;
       }
       return data;
     }, "Request"),
     Response: /* @__PURE__ */ __name((value) => {
-      if (!(value instanceof global2.Response)) return false;
+      if (!isInstanceOfPrototype(value, getHostClassPrototype(global2, "Response"))) return false;
       return {
-        type: value.type,
-        url: value.url,
-        status: value.status,
-        statusText: value.statusText,
-        headers: value.headers,
-        body: value.body,
-        redirected: value.redirected
+        type: readProperty(value, "type"),
+        url: readProperty(value, "url"),
+        status: readProperty(value, "status"),
+        statusText: readProperty(value, "statusText"),
+        headers: readProperty(value, "headers"),
+        body: readProperty(value, "body"),
+        redirected: readProperty(value, "redirected")
       };
     }, "Response")
   };
@@ -27222,48 +27962,63 @@ function getExternalReducers(global2 = globalThis, ops, runId, cryptoKey, framed
     }, "AbortSignal")
   };
 }
+function getStreamPrototype(global2, kind) {
+  return getHostClassPrototype(global2, `${kind}Stream`);
+}
+function getHostClassPrototype(global2, name) {
+  const ctor = global2[name] ?? globalThis[name] ?? void 0;
+  return typeof ctor === "function" ? ctor.prototype : void 0;
+}
+function getAbortControllerPrototype(global2) {
+  const ctor = global2.AbortController ?? globalThis.AbortController;
+  return typeof ctor === "function" ? ctor.prototype : void 0;
+}
+function getAbortSignalPrototype(global2) {
+  const ctor = global2.AbortSignal ?? globalThis.AbortSignal;
+  return typeof ctor === "function" ? ctor.prototype : void 0;
+}
 function getWorkflowReducers(global2 = globalThis) {
   return {
     ...getAllBaseReducers(global2),
     // Readable/Writable streams from within the workflow execution environment
     // are simply "handles" that can be passed around to other steps.
     ReadableStream: /* @__PURE__ */ __name((value) => {
-      if (!(value instanceof global2.ReadableStream)) return false;
-      const bodyInit = value[BODY_INIT_SYMBOL];
+      if (!isInstanceOfPrototype(value, getStreamPrototype(global2, "Readable"))) return false;
+      const bodyInit = readProperty(value, BODY_INIT_SYMBOL);
       if (bodyInit !== void 0) {
         return {
           bodyInit
         };
       }
-      const name = value[STREAM_NAME_SYMBOL];
+      const name = readProperty(value, STREAM_NAME_SYMBOL);
       if (!name) {
         throw new WorkflowRuntimeError("ReadableStream `name` is not set");
       }
       const s = {
         name
       };
-      const type = value[STREAM_TYPE_SYMBOL];
+      const type = readProperty(value, STREAM_TYPE_SYMBOL);
       if (type) s.type = type;
-      const framing = value[STREAM_FRAMING_SYMBOL];
+      const framing = readProperty(value, STREAM_FRAMING_SYMBOL);
       if (framing) s.framing = framing;
       return s;
     }, "ReadableStream"),
     WritableStream: /* @__PURE__ */ __name((value) => {
-      if (!(value instanceof global2.WritableStream)) return false;
-      const name = value[STREAM_NAME_SYMBOL];
+      if (!isInstanceOfPrototype(value, getStreamPrototype(global2, "Writable"))) return false;
+      const name = readProperty(value, STREAM_NAME_SYMBOL);
       if (!name) {
         throw new WorkflowRuntimeError("WritableStream `name` is not set");
       }
       const s = {
         name
       };
-      const foreignRunId = value[STREAM_SERVER_RUN_ID_SYMBOL];
+      const foreignRunId = readProperty(value, STREAM_SERVER_RUN_ID_SYMBOL);
       if (typeof foreignRunId === "string") s.runId = foreignRunId;
-      const foreignDeploymentId = value[STREAM_SERVER_DEPLOYMENT_ID_SYMBOL];
+      const foreignDeploymentId = readProperty(value, STREAM_SERVER_DEPLOYMENT_ID_SYMBOL);
       if (typeof foreignDeploymentId === "string") {
         s.deploymentId = foreignDeploymentId;
       }
-      const foreignPublicKey = value[STREAM_SERVER_PUBLIC_KEY_SYMBOL];
+      const foreignPublicKey = readProperty(value, STREAM_SERVER_PUBLIC_KEY_SYMBOL);
       if (typeof foreignPublicKey === "string") {
         s.encryptionPublicKey = foreignPublicKey;
       }
@@ -27274,17 +28029,24 @@ function getWorkflowReducers(global2 = globalThis) {
     // is a plain object (not a class), so instanceof checks won't work for signals.
     // Detect instances by the presence of the ABORT_STREAM_NAME symbol instead.
     AbortController: /* @__PURE__ */ __name((value) => {
-      if (!value || !value.signal) return false;
+      if (value === null || typeof value !== "object") return false;
       const holder = value;
-      const hasAbortSymbol = holder[ABORT_STREAM_NAME] ?? holder.signal?.[ABORT_STREAM_NAME];
-      const isNativeAbortController = global2.AbortController && typeof global2.AbortController === "function" && value instanceof global2.AbortController;
-      if (!hasAbortSymbol && !isNativeAbortController) return false;
-      return reduceAbortBySymbol(value.signal, holder);
+      const ownSymbol = readProperty(value, ABORT_STREAM_NAME);
+      const isNativeAbortController = isInstanceOfPrototype(value, getAbortControllerPrototype(global2));
+      if (ownSymbol === void 0 && !isNativeAbortController) {
+        const maybeSignal = readProperty(value, "signal");
+        if (maybeSignal === null || typeof maybeSignal !== "object" || readProperty(maybeSignal, ABORT_STREAM_NAME) === void 0) {
+          return false;
+        }
+      }
+      const signal = readProperty(value, "signal");
+      if (!signal) return false;
+      return reduceAbortBySymbol(signal, holder);
     }, "AbortController"),
     AbortSignal: /* @__PURE__ */ __name((value) => {
-      const signal = value;
-      const hasAbortSymbol = signal?.[ABORT_STREAM_NAME];
-      const isNativeAbortSignal = global2.AbortSignal && typeof global2.AbortSignal === "function" && value instanceof global2.AbortSignal;
+      if (value === null || typeof value !== "object") return false;
+      const hasAbortSymbol = readProperty(value, ABORT_STREAM_NAME) !== void 0;
+      const isNativeAbortSignal = isInstanceOfPrototype(value, getAbortSignalPrototype(global2));
       if (!hasAbortSymbol && !isNativeAbortSignal) return false;
       return reduceAbortBySymbol(value, value);
     }, "AbortSignal")
@@ -27812,20 +28574,25 @@ async function hydrateWorkflowReturnValue(value, runId, key, ops = [], global2 =
   await recordCompression(compressionStats, "deserialize");
   return result;
 }
-async function dehydrateStepArguments(value, _runId, key, global2 = globalThis, v1Compat = false, compression = false) {
+async function dehydrateStepArguments(value, _runId, key, global2 = globalThis, v1Compat = false, compression = false, guestCodeStatsOut) {
   if (v1Compat) {
     const str = stringify(value, getWorkflowReducers(global2));
     return revive(str);
   }
   try {
     const compressionStats = {};
+    const guestCodeStats = guestCodeStatsOut ?? {
+      executions: []
+    };
     const result = await serialize2(value, key, {
       global: global2,
       extraReducers: getStreamAndRequestReducers(getWorkflowReducers(global2)),
       compression,
-      compressionStats
+      compressionStats,
+      guestCodeStats
     });
     await recordCompression(compressionStats, "serialize");
+    await recordGuestCodeExecutions(guestCodeStats);
     return result;
   } catch (error48) {
     const cause = unwrapSerializationCause(error48);
@@ -27919,7 +28686,6 @@ var init_serialization2 = __esm({
     init_dist4();
     init_devalue();
     init_node();
-    init_sealed_box();
     init_encryption();
     init_flushable_stream();
     init_private();
@@ -27930,6 +28696,7 @@ var init_serialization2 = __esm({
     init_encryption2();
     init_errors3();
     init_format();
+    init_hardened();
     init_class();
     init_common();
     init_step_function();
@@ -27947,6 +28714,7 @@ var init_serialization2 = __esm({
     FRAME_HEADER_SIZE = 4;
     __name(unwrapSerializationCause, "unwrapSerializationCause");
     __name(recordCompression, "recordCompression");
+    __name(recordGuestCodeExecutions, "recordGuestCodeExecutions");
     __name(getSerializeStream, "getSerializeStream");
     __name(getDeserializeStream, "getDeserializeStream");
     MAX_FRAME_SIZE = 1e8;
@@ -28071,7 +28839,7 @@ var init_serialization2 = __esm({
         let inFlight = null;
         let sinkError;
         let resolvedFlushIntervalMs = getEnvStreamFlushIntervalMs();
-        let flushIntervalResolution = null;
+        let _flushIntervalResolution = null;
         const maxChunksPerRequest = getMaxChunksPerBatch();
         const maxBytesPerRequest = getMaxBytesPerBatch();
         const maxBufferedChunks = getMaxInflightChunks();
@@ -28169,7 +28937,7 @@ var init_serialization2 = __esm({
         const scheduleGroupCommit = /* @__PURE__ */ __name(() => {
           if (flushTimer || inFlight) return;
           if (resolvedFlushIntervalMs === void 0) {
-            flushIntervalResolution ??= Promise.resolve(worldPromise).then((world) => {
+            _flushIntervalResolution ??= Promise.resolve(worldPromise).then((world) => {
               resolvedFlushIntervalMs = world.streamFlushIntervalMs ?? STREAM_FLUSH_INTERVAL_MS;
             }, () => {
               resolvedFlushIntervalMs = STREAM_FLUSH_INTERVAL_MS;
@@ -28257,6 +29025,10 @@ var init_serialization2 = __esm({
     __name(reduceAbortBySymbol, "reduceAbortBySymbol");
     __name(attachAbortListenerOnce, "attachAbortListenerOnce");
     __name(getExternalReducers, "getExternalReducers");
+    __name(getStreamPrototype, "getStreamPrototype");
+    __name(getHostClassPrototype, "getHostClassPrototype");
+    __name(getAbortControllerPrototype, "getAbortControllerPrototype");
+    __name(getAbortSignalPrototype, "getAbortSignalPrototype");
     __name(getWorkflowReducers, "getWorkflowReducers");
     __name(getStepReducers, "getStepReducers");
     __name(setupAbortStreamReader, "setupAbortStreamReader");
@@ -28432,43 +29204,7 @@ __name(normalizeAttributeChanges, "normalizeAttributeChanges");
 
 // ../core/dist/runtime/start.js
 init_capabilities();
-
-// ../core/dist/classify-error.js
-init_dist2();
-var WORLD_CONTRACT_ERROR_CODES = /* @__PURE__ */ new Set([
-  "PARSE_ERROR",
-  "SCHEMA_VALIDATION",
-  RUN_ERROR_CODES.WORLD_CONTRACT_ERROR
-]);
-var RETRYABLE_WORLD_ERROR_CODES = /* @__PURE__ */ new Set([
-  "TRANSPORT",
-  "TIMEOUT"
-]);
-var RUNTIME_ERROR_CHECKS = [
-  WorkflowRuntimeError.is,
-  StepNotRegisteredError.is,
-  WorkflowNotRegisteredError.is,
-  // SDK-level encryption failures (most notably AES-GCM auth-tag
-  // mismatches surfacing as a native `OperationError` from
-  // `AESCipherJob.onDone`) are wrapped in `RuntimeDecryptionError` at
-  // the encryption module boundary.
-  RuntimeDecryptionError.is
-];
-function isRetryableWorldError(err) {
-  if (ThrottleError.is(err)) {
-    return true;
-  }
-  if (!WorkflowWorldError.is(err)) {
-    return false;
-  }
-  if (err.status !== void 0 && err.status >= 500) {
-    return true;
-  }
-  return err.code !== void 0 && RETRYABLE_WORLD_ERROR_CODES.has(err.code);
-}
-__name(isRetryableWorldError, "isRetryableWorldError");
-
-// ../core/dist/runtime/start.js
+init_classify_error();
 init_encryption();
 init_logger();
 init_sealed_box();
@@ -28538,13 +29274,16 @@ async function start(workflow, argsOrOptions, options) {
       const runId = `wrun_${world.createRunId ? world.createRunId(opts) : ulid3()}`;
       let framedByteStreams;
       let targetSupportsCompression;
+      let targetHookResumeInputVersion;
       let probedRunPublicKey;
       if (deploymentId === currentDeploymentId) {
         framedByteStreams = true;
         targetSupportsCompression = true;
+        targetHookResumeInputVersion = HOOK_RESUME_INPUT_VERSION;
       } else if (typeof world.streams?.get !== "function") {
         framedByteStreams = false;
         targetSupportsCompression = false;
+        targetHookResumeInputVersion = void 0;
       } else {
         const probe = await healthCheck(world, {
           deploymentId,
@@ -28556,6 +29295,7 @@ async function start(workflow, argsOrOptions, options) {
         const capabilities = getRunCapabilities(probe?.workflowCoreVersion);
         framedByteStreams = capabilities.framedByteStreams;
         targetSupportsCompression = capabilities.supportedFormats.has(SerializationFormat.GZIP);
+        targetHookResumeInputVersion = probe?.hookResumeInputVersion;
       }
       const ops = [];
       const traceCarrier = await serializeTraceCarrier();
@@ -28610,12 +29350,25 @@ async function start(workflow, argsOrOptions, options) {
       }
       const compression = targetSupportsCompression && specVersion >= SPEC_VERSION_SUPPORTS_COMPRESSION;
       const workflowArguments = await dehydrateWorkflowArguments(args, runId, encryptionKey, ops, globalThis, v1Compat, framedByteStreams, compression);
+      const creatorEnvironment = world.getEnvironment?.();
       const executionContext = {
         traceCarrier,
         workflowCoreVersion: version2,
         features: {
           encryption: !!encryptionKey
         },
+        // Attest that the *consumer* deployment's runtime re-ensures a
+        // `hook_received` event from a queue message's `hookInput` on replay.
+        // A resume of this run reads the marker (mirrored onto the hook's
+        // resumeContext by the server) to decide whether the parallel fast
+        // path is safe. For a cross-deployment start the consumer is the
+        // target deployment, so we stamp the *target's* value carried back on
+        // the health-check probe — never the caller's. Omitted when we could
+        // not attest the target (older target, timeout, or no probe channel),
+        // which fails the resume gate closed to the sequential path.
+        ...targetHookResumeInputVersion !== void 0 ? {
+          hookResumeInputVersion: targetHookResumeInputVersion
+        } : {},
         ...opts.replayedFromRunId ? {
           replayedFromRunId: opts.replayedFromRunId
         } : {}
@@ -28650,6 +29403,9 @@ async function start(workflow, argsOrOptions, options) {
               ...encryptionPublicKey ? {
                 encryptionPublicKey
               } : {},
+              ...creatorEnvironment !== void 0 ? {
+                environment: creatorEnvironment
+              } : {},
               ...attributeSeed
             }
           } : {}
@@ -28716,7 +29472,7 @@ __name(start, "start");
     value: "start",
     configurable: true
   });
-})(start, "step//@workflow/core/runtime/start@5.0.0-beta.38//start");
+})(start, "step//@workflow/core/runtime/start@5.0.0-beta.39//start");
 
 // ../core/dist/runtime/runs.js
 async function wakeUpRun(world, runId, options) {
@@ -29052,7 +29808,7 @@ var Run = class _Run {
     value: "wakeUp",
     configurable: true
   });
-})(Run.prototype["wakeUp"], "step//@workflow/core/runtime/run@5.0.0-beta.38//Run#wakeUp");
+})(Run.prototype["wakeUp"], "step//@workflow/core/runtime/run@5.0.0-beta.39//Run#wakeUp");
 (function(__wf_fn, __wf_id) {
   var __wf_sym = /* @__PURE__ */ Symbol.for("@workflow/core//registeredSteps"), __wf_reg = globalThis[__wf_sym] || (globalThis[__wf_sym] = /* @__PURE__ */ new Map());
   __wf_reg.set(__wf_id, __wf_fn);
@@ -29061,7 +29817,7 @@ var Run = class _Run {
     value: "cancel",
     configurable: true
   });
-})(Run.prototype["cancel"], "step//@workflow/core/runtime/run@5.0.0-beta.38//Run#cancel");
+})(Run.prototype["cancel"], "step//@workflow/core/runtime/run@5.0.0-beta.39//Run#cancel");
 (function(__wf_fn, __wf_id) {
   var __wf_sym = /* @__PURE__ */ Symbol.for("@workflow/core//registeredSteps"), __wf_reg = globalThis[__wf_sym] || (globalThis[__wf_sym] = /* @__PURE__ */ new Map());
   __wf_reg.set(__wf_id, __wf_fn);
@@ -29070,7 +29826,7 @@ var Run = class _Run {
     value: "getReadable",
     configurable: true
   });
-})(Run.prototype["getReadable"], "step//@workflow/core/runtime/run@5.0.0-beta.38//Run#getReadable");
+})(Run.prototype["getReadable"], "step//@workflow/core/runtime/run@5.0.0-beta.39//Run#getReadable");
 (function(__wf_fn, __wf_id) {
   var __wf_sym = /* @__PURE__ */ Symbol.for("@workflow/core//registeredSteps"), __wf_reg = globalThis[__wf_sym] || (globalThis[__wf_sym] = /* @__PURE__ */ new Map());
   __wf_reg.set(__wf_id, __wf_fn);
@@ -29079,7 +29835,7 @@ var Run = class _Run {
     value: "exists",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "exists").get, "step//@workflow/core/runtime/run@5.0.0-beta.38//Run#exists");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "exists").get, "step//@workflow/core/runtime/run@5.0.0-beta.39//Run#exists");
 (function(__wf_fn, __wf_id) {
   var __wf_sym = /* @__PURE__ */ Symbol.for("@workflow/core//registeredSteps"), __wf_reg = globalThis[__wf_sym] || (globalThis[__wf_sym] = /* @__PURE__ */ new Map());
   __wf_reg.set(__wf_id, __wf_fn);
@@ -29088,7 +29844,7 @@ var Run = class _Run {
     value: "status",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "status").get, "step//@workflow/core/runtime/run@5.0.0-beta.38//Run#status");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "status").get, "step//@workflow/core/runtime/run@5.0.0-beta.39//Run#status");
 (function(__wf_fn, __wf_id) {
   var __wf_sym = /* @__PURE__ */ Symbol.for("@workflow/core//registeredSteps"), __wf_reg = globalThis[__wf_sym] || (globalThis[__wf_sym] = /* @__PURE__ */ new Map());
   __wf_reg.set(__wf_id, __wf_fn);
@@ -29097,7 +29853,7 @@ var Run = class _Run {
     value: "returnValue",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "returnValue").get, "step//@workflow/core/runtime/run@5.0.0-beta.38//Run#returnValue");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "returnValue").get, "step//@workflow/core/runtime/run@5.0.0-beta.39//Run#returnValue");
 (function(__wf_fn, __wf_id) {
   var __wf_sym = /* @__PURE__ */ Symbol.for("@workflow/core//registeredSteps"), __wf_reg = globalThis[__wf_sym] || (globalThis[__wf_sym] = /* @__PURE__ */ new Map());
   __wf_reg.set(__wf_id, __wf_fn);
@@ -29106,7 +29862,7 @@ var Run = class _Run {
     value: "workflowName",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "workflowName").get, "step//@workflow/core/runtime/run@5.0.0-beta.38//Run#workflowName");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "workflowName").get, "step//@workflow/core/runtime/run@5.0.0-beta.39//Run#workflowName");
 (function(__wf_fn, __wf_id) {
   var __wf_sym = /* @__PURE__ */ Symbol.for("@workflow/core//registeredSteps"), __wf_reg = globalThis[__wf_sym] || (globalThis[__wf_sym] = /* @__PURE__ */ new Map());
   __wf_reg.set(__wf_id, __wf_fn);
@@ -29115,7 +29871,7 @@ var Run = class _Run {
     value: "createdAt",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "createdAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.38//Run#createdAt");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "createdAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.39//Run#createdAt");
 (function(__wf_fn, __wf_id) {
   var __wf_sym = /* @__PURE__ */ Symbol.for("@workflow/core//registeredSteps"), __wf_reg = globalThis[__wf_sym] || (globalThis[__wf_sym] = /* @__PURE__ */ new Map());
   __wf_reg.set(__wf_id, __wf_fn);
@@ -29124,7 +29880,7 @@ var Run = class _Run {
     value: "startedAt",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "startedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.38//Run#startedAt");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "startedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.39//Run#startedAt");
 (function(__wf_fn, __wf_id) {
   var __wf_sym = /* @__PURE__ */ Symbol.for("@workflow/core//registeredSteps"), __wf_reg = globalThis[__wf_sym] || (globalThis[__wf_sym] = /* @__PURE__ */ new Map());
   __wf_reg.set(__wf_id, __wf_fn);
@@ -29133,7 +29889,7 @@ var Run = class _Run {
     value: "completedAt",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "completedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.38//Run#completedAt");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "completedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.39//Run#completedAt");
 (function(__wf_cls, __wf_id) {
   var __wf_sym = /* @__PURE__ */ Symbol.for("workflow-class-registry"), __wf_reg = globalThis[__wf_sym] || (globalThis[__wf_sym] = /* @__PURE__ */ new Map());
   __wf_reg.set(__wf_id, __wf_cls);
@@ -29143,7 +29899,7 @@ var Run = class _Run {
     enumerable: false,
     configurable: false
   });
-})(Run, "class//@workflow/core/runtime/run@5.0.0-beta.38//Run");
+})(Run, "class//@workflow/core/runtime/run@5.0.0-beta.39//Run");
 
 // ../workflow/dist/stdlib.js
 async function fetch2(...args) {
@@ -29250,7 +30006,9 @@ function renderPlain(c) {
     const first = isLast ? "\u2570\u25B6 " : "\u251C\u25B6 ";
     const cont = isLast ? "   " : "\u2502  ";
     const raw = renderDetailPlain(detail).split("\n");
-    raw.forEach((line, i) => lines.push(`${i === 0 ? first : cont}${line}`));
+    raw.forEach((line, i) => {
+      lines.push(`${i === 0 ? first : cont}${line}`);
+    });
   });
   return lines.join("\n");
 }