@workflow/world-testing 5.0.0-beta.36 → 5.0.0-beta.37

package/dist/.well-known/workflow/v1/{step.mjs → __step_registrations.mjs}

@@ -396,7 +396,7 @@ function buildFramedDetails(hint2, slug) {
   });
   return out;
 }
-var BASE_URL, ERROR_SLUGS, WorkflowError, WorkflowWorldError, WorkflowRunFailedError, WorkflowRunNotCompletedError, WorkflowRuntimeError, RuntimeDecryptionError, SerializationError, StepNotRegisteredError, WorkflowNotRegisteredError, WorkflowRunNotFoundError, HookConflictError, HookNotFoundError, EntityConflictError, ThrottleError, WorkflowRunCancelledError, FatalError, RetryableError, FATAL_ERROR_KEY, RETRYABLE_ERROR_KEY, HOOK_CONFLICT_ERROR_KEY, RUNTIME_DECRYPTION_ERROR_KEY;
+var BASE_URL, ERROR_SLUGS, WorkflowError, WorkflowWorldError, WorkflowRunFailedError, WorkflowRunNotCompletedError, WorkflowRuntimeError, RuntimeDecryptionError, SerializationError, StepNotRegisteredError, WorkflowNotRegisteredError, WorkflowRunNotFoundError, HookConflictError, HookNotFoundError, EntityConflictError, RunExpiredError, ThrottleError, WorkflowRunCancelledError, FatalError, RetryableError, FATAL_ERROR_KEY, RETRYABLE_ERROR_KEY, HOOK_CONFLICT_ERROR_KEY, RUNTIME_DECRYPTION_ERROR_KEY;
 var init_dist2 = __esm({
   "../errors/dist/index.js"() {
     "use strict";
@@ -659,6 +659,18 @@ Caused by: ${options.cause.stack}`;
         return isError(value) && value.name === "EntityConflictError";
       }
     };
+    RunExpiredError = class extends WorkflowWorldError {
+      static {
+        __name(this, "RunExpiredError");
+      }
+      constructor(message) {
+        super(message);
+        this.name = "RunExpiredError";
+      }
+      static is(value) {
+        return isError(value) && value.name === "RunExpiredError";
+      }
+    };
     ThrottleError = class extends WorkflowWorldError {
       static {
         __name(this, "ThrottleError");
@@ -16787,7 +16799,14 @@ var init_events = __esm({
         input: SerializedDataSchema,
         executionContext: external_exports.record(external_exports.string(), external_exports.any()).optional(),
         attributes: external_exports.record(external_exports.string(), external_exports.string()).optional(),
-        allowReservedAttributes: external_exports.literal(true).optional()
+        allowReservedAttributes: external_exports.literal(true).optional(),
+        /**
+         * The run's X25519 public key (base64), stamped by SDKs that support
+         * sealed (`encp`) envelopes. Persisted onto the run entity so that
+         * cross-run writers can seal payloads to this run without holding its
+         * symmetric key. Not secret — see `WorkflowRunBaseSchema`.
+         */
+        encryptionPublicKey: external_exports.string().optional()
       })
     });
     RunStartedEventSchema = BaseEventSchema.extend({
@@ -16798,7 +16817,14 @@ var init_events = __esm({
         workflowName: external_exports.string().optional(),
         executionContext: external_exports.record(external_exports.string(), external_exports.any()).optional(),
         attributes: external_exports.record(external_exports.string(), external_exports.string()).optional(),
-        allowReservedAttributes: external_exports.literal(true).optional()
+        allowReservedAttributes: external_exports.literal(true).optional(),
+        /**
+         * Mirrors `run_created.eventData.encryptionPublicKey`. Carried here for
+         * the resilient-start path: when the `run_created` write failed, the
+         * server creates the run from this event instead, and without the key
+         * the run would silently lose its ability to receive sealed writes.
+         */
+        encryptionPublicKey: external_exports.string().optional()
       }).optional()
     });
     RunCompletedEventSchema = BaseEventSchema.extend({
@@ -16970,6 +16996,26 @@ var init_runs = __esm({
        * the attributes-mvp changelog entry.
        */
       attributes: external_exports.record(external_exports.string(), external_exports.string()).default({}),
+      /**
+       * The run's X25519 public key, base64-encoded (~44 chars).
+       *
+       * Lets any party that can read this run seal a payload *to* it without
+       * being able to read the run's data — used for cross-run writes such as a
+       * hook resumption from another deployment, or a child workflow writing into
+       * a forwarded stream. The matching private scalar is never stored: it is
+       * re-derived on demand from the deployment's own key material, so this
+       * field is not secret and its presence does not weaken the run's
+       * confidentiality.
+       *
+       * Stamped at run creation by SDKs that support sealed (`encp`) envelopes.
+       * **Presence is the writer-side gate**: a run only carries a public key if
+       * the runtime that created it could also open sealed payloads, and runs are
+       * pinned to their creating deployment. Writers therefore seal iff this
+       * field is set, and otherwise fall back to fetching the symmetric per-run
+       * key. Absent on runs created by older SDKs, and on worlds that do not
+       * implement `getEncryptionKeyForRun` (encryption disabled).
+       */
+      encryptionPublicKey: external_exports.string().optional(),
       expiredAt: external_exports.coerce.date().optional(),
       startedAt: external_exports.coerce.date().optional(),
       completedAt: external_exports.coerce.date().optional(),
@@ -17255,30 +17301,6 @@ var init_env_config = __esm({
   }
 });
 
-// ../world/dist/hooks.js
-var HookSchema;
-var init_hooks = __esm({
-  "../world/dist/hooks.js"() {
-    "use strict";
-    init_zod();
-    init_serialization();
-    HookSchema = external_exports.object({
-      runId: external_exports.string(),
-      hookId: external_exports.string(),
-      token: external_exports.string(),
-      ownerId: external_exports.string(),
-      projectId: external_exports.string(),
-      environment: external_exports.string(),
-      metadata: SerializedDataSchema.optional(),
-      createdAt: external_exports.coerce.date(),
-      // Optional in database for backwards compatibility, defaults to 1 (legacy) when reading
-      specVersion: external_exports.number().optional(),
-      isWebhook: external_exports.boolean().optional(),
-      isSystem: external_exports.boolean().optional()
-    });
-  }
-});
-
 // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/index.js
 var init_classic = __esm({
   "../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/index.js"() {
@@ -17302,19 +17324,22 @@ function resolveQueueNamespace(namespace) {
   return namespace ?? process.env.WORKFLOW_QUEUE_NAMESPACE ?? void 0;
 }
 function getQueueTopicPrefix(kind, namespace) {
+  if (kind !== "workflow") {
+    throw new Error(`Unsupported queue kind: ${kind}`);
+  }
   if (namespace !== void 0) {
     QueueNamespace.parse(namespace);
-    return `__${namespace}_wkf_${kind}_`;
+    return `__${namespace}_wkf_workflow_`;
   }
-  return `__wkf_${kind}_`;
+  return "__wkf_workflow_";
 }
-var QueuePrefix, ValidQueueName, QueueNamespace, MessageId, TraceCarrierSchema, RunInputSchema, WorkflowInvokePayloadSchema, StepInvokePayloadSchema, HealthCheckPayloadSchema, QueuePayloadSchema;
+var QueuePrefix, ValidQueueName, QueueNamespace, MessageId, TraceCarrierSchema, RunInputSchema, WorkflowInvokePayloadSchema, HealthCheckPayloadSchema, QueuePayloadSchema;
 var init_queue = __esm({
   "../world/dist/queue.js"() {
     "use strict";
     init_v4();
-    QueuePrefix = external_exports.string().regex(/^__(?:[a-z][a-z0-9]*_)?wkf_(?:workflow|step)_$/, "Must match __wkf_{workflow|step}_ or __{namespace}_wkf_{workflow|step}_");
-    ValidQueueName = external_exports.string().regex(/^__(?:[a-z][a-z0-9]*_)?wkf_(?:workflow|step)_.+$/, "Must be a valid queue name with a recognized prefix");
+    QueuePrefix = external_exports.string().regex(/^__(?:[a-z][a-z0-9]*_)?wkf_workflow_$/, "Must match __wkf_workflow_ or __{namespace}_wkf_workflow_");
+    ValidQueueName = external_exports.string().regex(/^__(?:[a-z][a-z0-9]*_)?wkf_workflow_.+$/, "Must be a valid queue name with a recognized prefix");
     QueueNamespace = external_exports.string().regex(/^[a-z][a-z0-9]*$/, "Must be lowercase alphanumeric, starting with a letter");
     __name(resolveQueueNamespace, "resolveQueueNamespace");
     __name(getQueueTopicPrefix, "getQueueTopicPrefix");
@@ -17354,26 +17379,71 @@ var init_queue = __esm({
       /** Run creation data, only present on the first queue delivery from start() */
       runInput: RunInputSchema.optional()
     });
-    StepInvokePayloadSchema = external_exports.object({
-      workflowName: external_exports.string(),
-      workflowRunId: external_exports.string(),
-      workflowStartedAt: external_exports.number(),
-      stepId: external_exports.string(),
-      traceCarrier: TraceCarrierSchema.optional(),
-      requestedAt: external_exports.coerce.date().optional()
-    });
     HealthCheckPayloadSchema = external_exports.object({
       __healthCheck: external_exports.literal(true),
-      correlationId: external_exports.string()
+      correlationId: external_exports.string(),
+      /**
+       * The run id the caller is about to create, when the probe is being used to
+       * prepare a cross-deployment `start()`.
+       *
+       * The responder runs inside the target deployment, so it can derive that
+       * run's public key locally from its own key material and return it in the
+       * probe response. That lets the caller seal the workflow arguments without
+       * a separate key lookup. Absent for probes issued for other reasons (CLI
+       * health command, dashboard), in which case no key is returned.
+       */
+      runId: external_exports.string().optional()
     });
     QueuePayloadSchema = external_exports.union([
-      WorkflowInvokePayloadSchema,
-      StepInvokePayloadSchema,
-      HealthCheckPayloadSchema
+      HealthCheckPayloadSchema,
+      WorkflowInvokePayloadSchema
     ]);
   }
 });
 
+// ../world/dist/hooks.js
+var HookResumeContextSchema, HookSchema;
+var init_hooks = __esm({
+  "../world/dist/hooks.js"() {
+    "use strict";
+    init_zod();
+    init_queue();
+    init_serialization();
+    HookResumeContextSchema = external_exports.object({
+      deploymentId: external_exports.string(),
+      workflowName: external_exports.string(),
+      // Named `runSpecVersion` to distinguish it from the hook's own `specVersion`.
+      runSpecVersion: external_exports.number().optional(),
+      workflowCoreVersion: external_exports.string().optional(),
+      traceCarrier: TraceCarrierSchema.optional(),
+      // The run's published X25519 public key (base64), mirrored from the run
+      // entity. Lets a resume seal (`encp`) its payload to the run without reading
+      // 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()
+    });
+    HookSchema = external_exports.object({
+      runId: external_exports.string(),
+      hookId: external_exports.string(),
+      token: external_exports.string(),
+      ownerId: external_exports.string(),
+      projectId: external_exports.string(),
+      environment: external_exports.string(),
+      metadata: SerializedDataSchema.optional(),
+      createdAt: external_exports.coerce.date(),
+      // Optional in database for backwards compatibility, defaults to 1 (legacy) when reading
+      specVersion: external_exports.number().optional(),
+      isWebhook: external_exports.boolean().optional(),
+      isSystem: external_exports.boolean().optional(),
+      // 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()
+    });
+  }
+});
+
 // ../world/dist/recovery.js
 var init_recovery = __esm({
   "../world/dist/recovery.js"() {
@@ -17632,14 +17702,17 @@ async function importKey(raw, usages = [
     usages
   );
 }
-async function encrypt(key, data) {
+async function encrypt(key, data, aad) {
   const nonce = globalThis.crypto.getRandomValues(new Uint8Array(NONCE_LENGTH));
   let ciphertext;
   try {
     ciphertext = await globalThis.crypto.subtle.encrypt({
       name: "AES-GCM",
       iv: nonce,
-      tagLength: TAG_LENGTH
+      tagLength: TAG_LENGTH,
+      ...aad ? {
+        additionalData: aad
+      } : {}
     }, key, data);
   } catch (cause) {
     throw new RuntimeDecryptionError(`AES-256-GCM encryption failed: ${cause instanceof Error ? cause.message : String(cause)}`, {
@@ -17655,7 +17728,7 @@ async function encrypt(key, data) {
   result.set(new Uint8Array(ciphertext), NONCE_LENGTH);
   return result;
 }
-async function decrypt(key, data) {
+async function decrypt(key, data, aad) {
   const minLength = NONCE_LENGTH + TAG_LENGTH / 8;
   if (data.byteLength < minLength) {
     throw new RuntimeDecryptionError(`Encrypted data too short: expected at least ${minLength} bytes, got ${data.byteLength}`, {
@@ -17672,7 +17745,10 @@ async function decrypt(key, data) {
     plaintext = await globalThis.crypto.subtle.decrypt({
       name: "AES-GCM",
       iv: nonce,
-      tagLength: TAG_LENGTH
+      tagLength: TAG_LENGTH,
+      ...aad ? {
+        additionalData: aad
+      } : {}
     }, key, ciphertext);
   } catch (cause) {
     const causeMsg = cause instanceof Error ? cause.message : String(cause);
@@ -17686,13 +17762,14 @@ async function decrypt(key, data) {
   }
   return new Uint8Array(plaintext);
 }
-var NONCE_LENGTH, TAG_LENGTH, KEY_LENGTH;
+var NONCE_LENGTH, TAG_LENGTH, TAG_BYTES, KEY_LENGTH;
 var init_encryption = __esm({
   "../core/dist/encryption.js"() {
     "use strict";
     init_dist2();
     NONCE_LENGTH = 12;
     TAG_LENGTH = 128;
+    TAG_BYTES = TAG_LENGTH / 8;
     KEY_LENGTH = 32;
     __name(importKey, "importKey");
     __name(encrypt, "encrypt");
@@ -17700,140 +17777,708 @@ var init_encryption = __esm({
   }
 });
 
-// ../../node_modules/.pnpm/devalue@5.8.1/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"() {
-    "use strict";
-    UNDEFINED = -1;
-    HOLE = -2;
-    NAN = -3;
-    POSITIVE_INFINITY = -4;
-    NEGATIVE_INFINITY = -5;
-    NEGATIVE_ZERO = -6;
-    SPARSE = -7;
-    MAX_ARRAY_LEN = 2 ** 32 - 1;
-    MAX_ARRAY_INDEX = MAX_ARRAY_LEN - 1;
+// ../core/dist/sealed-box.js
+function assertKeyMaterialLength(runKeyMaterial) {
+  if (runKeyMaterial.byteLength !== CONTENT_KEY_LENGTH) {
+    throw new WorkflowRuntimeError(`Run key material must be exactly ${CONTENT_KEY_LENGTH} bytes, got ${runKeyMaterial.byteLength}`);
   }
-});
-
-// ../../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";
 }
-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;
+function assertPublicKeyLength(publicKey, label) {
+  if (publicKey.byteLength !== X25519_KEY_LENGTH) {
+    throw new WorkflowRuntimeError(`${label} must be exactly ${X25519_KEY_LENGTH} bytes, got ${publicKey.byteLength}`);
+  }
 }
-function get_type(thing) {
-  return Object.prototype.toString.call(thing).slice(8, -1);
+async function deriveRunKeyPair(runKeyMaterial) {
+  assertKeyMaterialLength(runKeyMaterial);
+  const hkdfKey = await globalThis.crypto.subtle.importKey("raw", runKeyMaterial, "HKDF", false, [
+    "deriveBits"
+  ]);
+  const scalarBits = await globalThis.crypto.subtle.deriveBits({
+    name: "HKDF",
+    hash: "SHA-256",
+    salt: new Uint8Array(32),
+    info: infoEncoder.encode(SCALAR_INFO)
+  }, hkdfKey, X25519_KEY_LENGTH * 8);
+  const scalar = new Uint8Array(scalarBits);
+  const publicKey = await derivePublicKeyFromScalar(scalar);
+  return {
+    scalar,
+    publicKey
+  };
 }
-function get_escaped_char(char) {
-  switch (char) {
-    case '"':
-      return '\\"';
-    case "<":
-      return "\\u003C";
-    case "\\":
-      return "\\\\";
-    case "\n":
-      return "\\n";
-    case "\r":
-      return "\\r";
-    case "	":
-      return "\\t";
-    case "\b":
-      return "\\b";
-    case "\f":
-      return "\\f";
-    case "\u2028":
-      return "\\u2028";
-    case "\u2029":
-      return "\\u2029";
-    default:
-      return char < " " ? `\\u${char.charCodeAt(0).toString(16).padStart(4, "0")}` : "";
+async function derivePublicKeyFromScalar(scalar) {
+  const privateKey = await importScalar(
+    scalar,
+    /* extractable */
+    true
+  );
+  const jwk = await globalThis.crypto.subtle.exportKey("jwk", privateKey);
+  if (!jwk.x) {
+    throw new WorkflowRuntimeError('X25519 JWK export did not include a public key component ("x")');
+  }
+  const publicKey = base64UrlToBytes(jwk.x);
+  if (publicKey.byteLength !== X25519_KEY_LENGTH) {
+    throw new WorkflowRuntimeError(`X25519 JWK export produced a ${publicKey.byteLength}-byte public key, expected ${X25519_KEY_LENGTH}`);
+  }
+  return publicKey;
+}
+async function importScalar(scalar, extractable) {
+  const pkcs8 = new Uint8Array(PKCS8_X25519_PREFIX.length + scalar.byteLength);
+  pkcs8.set(PKCS8_X25519_PREFIX, 0);
+  pkcs8.set(scalar, PKCS8_X25519_PREFIX.length);
+  return globalThis.crypto.subtle.importKey("pkcs8", pkcs8, {
+    name: "X25519"
+  }, extractable, [
+    "deriveBits"
+  ]);
+}
+function importPublicKey(publicKey) {
+  return globalThis.crypto.subtle.importKey(
+    "raw",
+    publicKey,
+    {
+      name: "X25519"
+    },
+    /* extractable */
+    true,
+    // Public keys carry no usages for X25519 — the private key does the
+    // deriving; the public key is only ever an argument to it.
+    []
+  );
+}
+function bytesToBase64(bytes) {
+  let out = "";
+  for (let i = 0; i < bytes.length; i += 3) {
+    const b0 = bytes[i];
+    const b1 = i + 1 < bytes.length ? bytes[i + 1] : 0;
+    const b2 = i + 2 < bytes.length ? bytes[i + 2] : 0;
+    out += BASE64_CHARS[b0 >> 2 & 63];
+    out += BASE64_CHARS[(b0 & 3) << 4 | b1 >> 4 & 15];
+    out += i + 1 < bytes.length ? BASE64_CHARS[(b1 & 15) << 2 | b2 >> 6 & 3] : "=";
+    out += i + 2 < bytes.length ? BASE64_CHARS[b2 & 63] : "=";
   }
+  return out;
 }
-function stringify_string(str) {
-  let result = "";
-  let last_pos = 0;
-  const len = str.length;
-  for (let i = 0; i < len; i += 1) {
-    const char = str[i];
-    const replacement = get_escaped_char(char);
-    if (replacement) {
-      result += str.slice(last_pos, i) + replacement;
-      last_pos = i + 1;
+function base64ToBytes(value) {
+  let end = value.length;
+  while (end > 0 && value[end - 1] === "=") end--;
+  const body = value.slice(0, end);
+  if (body.includes("=")) return void 0;
+  if (body.length % 4 === 1) return void 0;
+  if (end !== value.length && value.length % 4 !== 0) return void 0;
+  let accumulator = 0;
+  let bitCount = 0;
+  const bytes = [];
+  for (let i = 0; i < body.length; i++) {
+    const index = BASE64_CHARS.indexOf(body[i]);
+    if (index === -1) return void 0;
+    accumulator = accumulator << 6 | index;
+    bitCount += 6;
+    if (bitCount >= 8) {
+      bitCount -= 8;
+      bytes.push(accumulator >> bitCount & 255);
     }
   }
-  return `"${last_pos === 0 ? str : result + str.slice(last_pos)}"`;
+  if (bitCount > 0 && (accumulator & (1 << bitCount) - 1) !== 0) {
+    return void 0;
+  }
+  return new Uint8Array(bytes);
+}
+function base64UrlToBytes(value) {
+  let accumulator = 0;
+  let bitCount = 0;
+  const bytes = [];
+  for (let i = 0; i < value.length; i++) {
+    const char = value[i];
+    if (char === "=") break;
+    const index = BASE64URL_CHARS.indexOf(char);
+    if (index === -1) {
+      throw new WorkflowRuntimeError(`Invalid base64url character "${char}" in X25519 JWK key component`);
+    }
+    accumulator = accumulator << 6 | index;
+    bitCount += 6;
+    if (bitCount >= 8) {
+      bitCount -= 8;
+      bytes.push(accumulator >> bitCount & 255);
+    }
+  }
+  return new Uint8Array(bytes);
 }
-function enumerable_symbols(object2) {
-  return Object.getOwnPropertySymbols(object2).filter((symbol2) => Object.getOwnPropertyDescriptor(object2, symbol2).enumerable);
+async function deriveContentKey(sharedSecret, ephemeralPublicKey, recipientPublicKey, usages) {
+  const label = infoEncoder.encode(CONTENT_KEY_INFO);
+  const info = new Uint8Array(label.length + ephemeralPublicKey.length + recipientPublicKey.length);
+  info.set(label, 0);
+  info.set(ephemeralPublicKey, label.length);
+  info.set(recipientPublicKey, label.length + ephemeralPublicKey.length);
+  const hkdfKey = await globalThis.crypto.subtle.importKey("raw", sharedSecret, "HKDF", false, [
+    "deriveBits"
+  ]);
+  const contentKeyBits = await globalThis.crypto.subtle.deriveBits({
+    name: "HKDF",
+    hash: "SHA-256",
+    salt: new Uint8Array(32),
+    info
+  }, hkdfKey, CONTENT_KEY_LENGTH * 8);
+  return globalThis.crypto.subtle.importKey(
+    "raw",
+    new Uint8Array(contentKeyBits),
+    "AES-GCM",
+    false,
+    // `KeyUsage` is a DOM-lib type that is not in scope under `es2022`; the
+    // parameter type is a strict subset of it, so this cast is sound.
+    usages
+  );
 }
-function stringify_key(key) {
-  return is_identifier.test(key) ? "." + key : "[" + JSON.stringify(key) + "]";
+async function encapsulate(recipientPublicKey) {
+  assertPublicKeyLength(recipientPublicKey, "Recipient public key");
+  let recipientKey;
+  try {
+    recipientKey = await importPublicKey(recipientPublicKey);
+  } catch (cause) {
+    throw new WorkflowRuntimeError(`Invalid X25519 recipient public key: ${cause instanceof Error ? cause.message : String(cause)}`, {
+      cause
+    });
+  }
+  const ephemeral = await globalThis.crypto.subtle.generateKey(
+    {
+      name: "X25519"
+    },
+    /* extractable */
+    true,
+    [
+      "deriveBits"
+    ]
+  );
+  const ephemeralPublicKey = new Uint8Array(await globalThis.crypto.subtle.exportKey("raw", ephemeral.publicKey));
+  let sharedSecretBits;
+  try {
+    sharedSecretBits = await globalThis.crypto.subtle.deriveBits({
+      name: "X25519",
+      public: recipientKey
+    }, ephemeral.privateKey, X25519_KEY_LENGTH * 8);
+  } catch (cause) {
+    throw new WorkflowRuntimeError("X25519 key agreement failed: the recipient public key is not a valid curve point (low-order point or corrupted key material)", {
+      cause
+    });
+  }
+  const contentKey = await deriveContentKey(new Uint8Array(sharedSecretBits), ephemeralPublicKey, recipientPublicKey, [
+    "encrypt"
+  ]);
+  return {
+    ephemeralPublicKey,
+    contentKey
+  };
 }
-function is_valid_array_index(n) {
-  if (!Number.isInteger(n)) return false;
-  if (n < 0) return false;
-  if (n > MAX_ARRAY_INDEX) return false;
-  return true;
+async function decapsulate(keyPair, ephemeralPublicKey) {
+  if (ephemeralPublicKey.byteLength !== X25519_KEY_LENGTH) {
+    throw new RuntimeDecryptionError(`Sealed payload has a malformed ephemeral public key: expected ${X25519_KEY_LENGTH} bytes, got ${ephemeralPublicKey.byteLength}`, {
+      context: {
+        operation: "decrypt",
+        byteLength: ephemeralPublicKey.byteLength
+      }
+    });
+  }
+  let sharedSecretBits;
+  try {
+    const [privateKey, senderKey] = await Promise.all([
+      importScalar(
+        keyPair.scalar,
+        /* extractable */
+        false
+      ),
+      importPublicKey(ephemeralPublicKey)
+    ]);
+    sharedSecretBits = await globalThis.crypto.subtle.deriveBits({
+      name: "X25519",
+      public: senderKey
+    }, privateKey, X25519_KEY_LENGTH * 8);
+  } catch (cause) {
+    throw new RuntimeDecryptionError(`X25519 key agreement failed while opening a sealed payload: ${cause instanceof Error ? cause.message : String(cause)}`, {
+      cause,
+      context: {
+        operation: "decrypt",
+        byteLength: ephemeralPublicKey.byteLength
+      }
+    });
+  }
+  return deriveContentKey(new Uint8Array(sharedSecretBits), ephemeralPublicKey, keyPair.publicKey, [
+    "decrypt"
+  ]);
 }
-function is_valid_array_len(n) {
-  if (!Number.isInteger(n)) return false;
-  if (n < 0) return false;
-  if (n > MAX_ARRAY_LEN) return false;
-  return true;
+async function seal(recipientPublicKey, data, aad) {
+  const { ephemeralPublicKey, contentKey } = await encapsulate(recipientPublicKey);
+  const encrypted = await encrypt(contentKey, data, aad);
+  const result = new Uint8Array(ephemeralPublicKey.byteLength + encrypted.byteLength);
+  result.set(ephemeralPublicKey, 0);
+  result.set(encrypted, ephemeralPublicKey.byteLength);
+  return result;
 }
-function is_valid_array_index_string(s) {
-  if (s.length === 0) return false;
-  if (s.length > 1 && s.charCodeAt(0) === 48) return false;
-  for (let i = 0; i < s.length; i++) {
-    const c = s.charCodeAt(i);
-    if (c < 48 || c > 57) return false;
+async function open(keyPair, sealed, aad) {
+  const minLength = X25519_KEY_LENGTH + NONCE_LENGTH + TAG_BYTES;
+  if (sealed.byteLength < minLength) {
+    throw new RuntimeDecryptionError(`Sealed payload too short: expected at least ${minLength} bytes, got ${sealed.byteLength}`, {
+      context: {
+        operation: "decrypt",
+        byteLength: sealed.byteLength
+      }
+    });
   }
-  return is_valid_array_index(+s);
+  const ephemeralPublicKey = sealed.subarray(0, X25519_KEY_LENGTH);
+  const encrypted = sealed.subarray(X25519_KEY_LENGTH);
+  const contentKey = await decapsulate(keyPair, ephemeralPublicKey);
+  return decrypt(contentKey, encrypted, aad);
 }
-function valid_array_indices(array2) {
-  const keys = Object.keys(array2);
-  for (var i = keys.length - 1; i >= 0; i--) {
-    if (is_valid_array_index_string(keys[i])) {
-      break;
+function createSealSession(recipientPublicKey, aad) {
+  let encapsulation;
+  return {
+    async seal(data) {
+      encapsulation ??= encapsulate(recipientPublicKey);
+      const { ephemeralPublicKey, contentKey } = await encapsulation;
+      const encrypted = await encrypt(contentKey, data, aad);
+      const result = new Uint8Array(ephemeralPublicKey.byteLength + encrypted.byteLength);
+      result.set(ephemeralPublicKey, 0);
+      result.set(encrypted, ephemeralPublicKey.byteLength);
+      return result;
     }
-  }
-  keys.length = i + 1;
-  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"() {
-    "use strict";
-    init_constants();
-    DevalueError = class extends Error {
-      static {
-        __name(this, "DevalueError");
+function createOpenSession(keyPair, aad) {
+  let cachedSender;
+  let cachedKey;
+  return {
+    async open(sealed) {
+      const minLength = X25519_KEY_LENGTH + NONCE_LENGTH + TAG_BYTES;
+      if (sealed.byteLength < minLength) {
+        throw new RuntimeDecryptionError(`Sealed payload too short: expected at least ${minLength} bytes, got ${sealed.byteLength}`, {
+          context: {
+            operation: "decrypt",
+            byteLength: sealed.byteLength
+          }
+        });
       }
-      /**
-      * @param {string} message
-      * @param {string[]} keys
-      * @param {any} [value] - The value that failed to be serialized
-      * @param {any} [root] - The root value being serialized
-      */
-      constructor(message, keys, value, root) {
-        super(message);
-        this.name = "DevalueError";
-        this.path = keys.join("");
-        this.value = value;
-        this.root = root;
+      const ephemeralPublicKey = sealed.subarray(0, X25519_KEY_LENGTH);
+      const encrypted = sealed.subarray(X25519_KEY_LENGTH);
+      const sender = keyCacheId(ephemeralPublicKey);
+      if (sender !== cachedSender || !cachedKey) {
+        cachedSender = sender;
+        cachedKey = decapsulate(keyPair, ephemeralPublicKey);
       }
-    };
-    __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");
-    __name(get_escaped_char, "get_escaped_char");
-    __name(stringify_string, "stringify_string");
+      let contentKey;
+      try {
+        contentKey = await cachedKey;
+      } catch (error48) {
+        cachedSender = void 0;
+        cachedKey = void 0;
+        throw error48;
+      }
+      return decrypt(contentKey, encrypted, aad);
+    }
+  };
+}
+function keyCacheId(publicKey) {
+  let id = "";
+  for (let i = 0; i < publicKey.length; i++) {
+    id += publicKey[i].toString(16).padStart(2, "0");
+  }
+  return id;
+}
+function decodeRunPublicKey(value) {
+  if (!value) return void 0;
+  const bytes = base64ToBytes(value);
+  if (!bytes || bytes.byteLength !== X25519_KEY_LENGTH) return void 0;
+  return bytes;
+}
+var X25519_KEY_LENGTH, CONTENT_KEY_LENGTH, SCALAR_INFO, CONTENT_KEY_INFO, PKCS8_X25519_PREFIX, infoEncoder, BASE64_CHARS, BASE64URL_CHARS;
+var init_sealed_box = __esm({
+  "../core/dist/sealed-box.js"() {
+    "use strict";
+    init_dist2();
+    init_encryption();
+    X25519_KEY_LENGTH = 32;
+    CONTENT_KEY_LENGTH = 32;
+    SCALAR_INFO = "workflow/encp/x25519/v1";
+    CONTENT_KEY_INFO = "workflow/encp/aes256gcm/v1";
+    PKCS8_X25519_PREFIX = new Uint8Array([
+      48,
+      46,
+      2,
+      1,
+      0,
+      48,
+      5,
+      6,
+      3,
+      43,
+      101,
+      110,
+      4,
+      34,
+      4,
+      32
+    ]);
+    infoEncoder = new TextEncoder();
+    __name(assertKeyMaterialLength, "assertKeyMaterialLength");
+    __name(assertPublicKeyLength, "assertPublicKeyLength");
+    __name(deriveRunKeyPair, "deriveRunKeyPair");
+    __name(derivePublicKeyFromScalar, "derivePublicKeyFromScalar");
+    __name(importScalar, "importScalar");
+    __name(importPublicKey, "importPublicKey");
+    BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    BASE64URL_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+    __name(bytesToBase64, "bytesToBase64");
+    __name(base64ToBytes, "base64ToBytes");
+    __name(base64UrlToBytes, "base64UrlToBytes");
+    __name(deriveContentKey, "deriveContentKey");
+    __name(encapsulate, "encapsulate");
+    __name(decapsulate, "decapsulate");
+    __name(seal, "seal");
+    __name(open, "open");
+    __name(createSealSession, "createSealSession");
+    __name(createOpenSession, "createOpenSession");
+    __name(keyCacheId, "keyCacheId");
+    __name(decodeRunPublicKey, "decodeRunPublicKey");
+  }
+});
+
+// ../core/dist/serialization/types.js
+function isFormatPrefix(value) {
+  return value.length === 4 && /^[a-z0-9]{4}$/.test(value);
+}
+var SerializationFormat;
+var init_types = __esm({
+  "../core/dist/serialization/types.js"() {
+    "use strict";
+    __name(isFormatPrefix, "isFormatPrefix");
+    SerializationFormat = {
+      /** devalue stringify/parse with TextEncoder/TextDecoder */
+      DEVALUE_V1: "devl",
+      /** Encrypted payload (inner payload has its own format prefix) */
+      ENCRYPTED: "encr",
+      /**
+       * Sealed payload — asymmetrically encrypted to a run's X25519 public key
+       * (inner payload has its own format prefix).
+       *
+       * Used for *cross-run* writes (hook payloads, forwarded stream frames),
+       * where the writer holds only the recipient run's public key and therefore
+       * cannot decrypt. A run's own payloads continue to use {@link ENCRYPTED}.
+       * See `sealed-box.ts` for the construction.
+       */
+      SEALED: "encp",
+      /** Gzip-compressed payload (inner payload has its own format prefix) */
+      GZIP: "gzip",
+      /** Zstandard-compressed payload (inner payload has its own format prefix) */
+      ZSTD: "zstd"
+    };
+  }
+});
+
+// ../core/dist/serialization/format.js
+function encodeWithFormatPrefix(format, payload) {
+  if (!(payload instanceof Uint8Array)) {
+    return payload;
+  }
+  const prefixBytes = formatEncoder.encode(format);
+  const result = new Uint8Array(FORMAT_PREFIX_LENGTH + payload.length);
+  result.set(prefixBytes, 0);
+  result.set(payload, FORMAT_PREFIX_LENGTH);
+  return result;
+}
+function peekFormatPrefix(data) {
+  if (!(data instanceof Uint8Array) || data.length < FORMAT_PREFIX_LENGTH) {
+    return null;
+  }
+  const prefixBytes = data.subarray(0, FORMAT_PREFIX_LENGTH);
+  const str = formatDecoder.decode(prefixBytes);
+  return isFormatPrefix(str) ? str : null;
+}
+function decodeFormatPrefix(data) {
+  if (!(data instanceof Uint8Array)) {
+    return {
+      format: SerializationFormat.DEVALUE_V1,
+      payload: new TextEncoder().encode(JSON.stringify(data))
+    };
+  }
+  if (data.length < FORMAT_PREFIX_LENGTH) {
+    throw new Error(`Data too short to contain format prefix: expected at least ${FORMAT_PREFIX_LENGTH} bytes, got ${data.length}`);
+  }
+  const prefixBytes = data.subarray(0, FORMAT_PREFIX_LENGTH);
+  const str = formatDecoder.decode(prefixBytes);
+  if (!isFormatPrefix(str)) {
+    throw new Error(`Invalid format prefix: "${str}". Must be 4 characters of [a-z0-9].`);
+  }
+  const payload = data.subarray(FORMAT_PREFIX_LENGTH);
+  return {
+    format: str,
+    payload
+  };
+}
+var FORMAT_PREFIX_LENGTH, formatEncoder, formatDecoder;
+var init_format = __esm({
+  "../core/dist/serialization/format.js"() {
+    "use strict";
+    init_types();
+    FORMAT_PREFIX_LENGTH = 4;
+    formatEncoder = new TextEncoder();
+    formatDecoder = new TextDecoder();
+    __name(encodeWithFormatPrefix, "encodeWithFormatPrefix");
+    __name(peekFormatPrefix, "peekFormatPrefix");
+    __name(decodeFormatPrefix, "decodeFormatPrefix");
+  }
+});
+
+// ../core/dist/serialization/encryption.js
+function sealTo(recipientPublicKey, aad) {
+  return {
+    [SEAL_TARGET_BRAND]: true,
+    recipientPublicKey,
+    aad
+  };
+}
+function runPayloadKeys(aes, keyPair, aad) {
+  return {
+    [RUN_KEYS_BRAND]: true,
+    aes,
+    keyPair,
+    aad
+  };
+}
+async function deriveRunPayloadKeys(runKeyMaterial) {
+  const [aes, keyPair] = await Promise.all([
+    importKey(runKeyMaterial),
+    deriveRunKeyPair(runKeyMaterial)
+  ]);
+  return runPayloadKeys(aes, keyPair);
+}
+function isSealTarget(value) {
+  return typeof value === "object" && value !== null && value[SEAL_TARGET_BRAND] === true;
+}
+function isRunPayloadKeys(value) {
+  return typeof value === "object" && value !== null && value[RUN_KEYS_BRAND] === true;
+}
+function aesKeyOf(key) {
+  if (!key) return void 0;
+  if (isRunPayloadKeys(key)) return key.aes;
+  if (isSealTarget(key)) return void 0;
+  return key;
+}
+async function resolveEncryptionKey(key) {
+  return typeof key === "function" ? key() : key;
+}
+async function encrypt2(data, key) {
+  if (!key || !(data instanceof Uint8Array)) return data;
+  if (isSealTarget(key)) {
+    const sealed = await seal(key.recipientPublicKey, data, key.aad);
+    return encodeWithFormatPrefix(SerializationFormat.SEALED, sealed);
+  }
+  const aesKey = isRunPayloadKeys(key) ? key.aes : key;
+  const encrypted = await encrypt(aesKey, data);
+  return encodeWithFormatPrefix(SerializationFormat.ENCRYPTED, encrypted);
+}
+async function openSealedEnvelope(data, key) {
+  if (!isRunPayloadKeys(key)) {
+    throw new RuntimeDecryptionError("Sealed data encountered but no run keypair is available. Opening a sealed payload requires the run's own encryption key material; a symmetric key or a seal-only target cannot decrypt it.", {
+      context: {
+        operation: "decrypt",
+        byteLength: data.byteLength,
+        formatPrefix: "encp"
+      }
+    });
+  }
+  const { payload } = decodeFormatPrefix(data);
+  try {
+    return await open(key.keyPair, payload, key.aad);
+  } catch (error48) {
+    if (RuntimeDecryptionError.is(error48) && error48.context) {
+      error48.context.formatPrefix = SerializationFormat.SEALED;
+    }
+    throw error48;
+  }
+}
+async function decrypt2(data, key) {
+  if (!(data instanceof Uint8Array)) return data;
+  const format = peekFormatPrefix(data);
+  if (format === SerializationFormat.SEALED) {
+    return openSealedEnvelope(data, key);
+  }
+  if (format !== SerializationFormat.ENCRYPTED) return data;
+  const aesKey = aesKeyOf(key);
+  if (!aesKey) {
+    throw new RuntimeDecryptionError("Encrypted data encountered but no encryption key is available. Encryption is not configured or no key was provided for this run.", {
+      context: {
+        operation: "decrypt",
+        byteLength: data.byteLength,
+        formatPrefix: "encr"
+      }
+    });
+  }
+  const { payload } = decodeFormatPrefix(data);
+  try {
+    return await decrypt(aesKey, payload);
+  } catch (error48) {
+    if (RuntimeDecryptionError.is(error48) && error48.context) {
+      error48.context.formatPrefix = format;
+    }
+    throw error48;
+  }
+}
+var SEAL_TARGET_BRAND, RUN_KEYS_BRAND;
+var init_encryption2 = __esm({
+  "../core/dist/serialization/encryption.js"() {
+    "use strict";
+    init_dist2();
+    init_encryption();
+    init_sealed_box();
+    init_format();
+    init_types();
+    SEAL_TARGET_BRAND = /* @__PURE__ */ Symbol.for("workflow.serialization.sealTarget");
+    RUN_KEYS_BRAND = /* @__PURE__ */ Symbol.for("workflow.serialization.runKeys");
+    __name(sealTo, "sealTo");
+    __name(runPayloadKeys, "runPayloadKeys");
+    __name(deriveRunPayloadKeys, "deriveRunPayloadKeys");
+    __name(isSealTarget, "isSealTarget");
+    __name(isRunPayloadKeys, "isRunPayloadKeys");
+    __name(aesKeyOf, "aesKeyOf");
+    __name(resolveEncryptionKey, "resolveEncryptionKey");
+    __name(encrypt2, "encrypt");
+    __name(openSealedEnvelope, "openSealedEnvelope");
+    __name(decrypt2, "decrypt");
+  }
+});
+
+// ../../node_modules/.pnpm/devalue@5.8.1/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"() {
+    "use strict";
+    UNDEFINED = -1;
+    HOLE = -2;
+    NAN = -3;
+    POSITIVE_INFINITY = -4;
+    NEGATIVE_INFINITY = -5;
+    NEGATIVE_ZERO = -6;
+    SPARSE = -7;
+    MAX_ARRAY_LEN = 2 ** 32 - 1;
+    MAX_ARRAY_INDEX = MAX_ARRAY_LEN - 1;
+  }
+});
+
+// ../../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";
+}
+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;
+}
+function get_type(thing) {
+  return Object.prototype.toString.call(thing).slice(8, -1);
+}
+function get_escaped_char(char) {
+  switch (char) {
+    case '"':
+      return '\\"';
+    case "<":
+      return "\\u003C";
+    case "\\":
+      return "\\\\";
+    case "\n":
+      return "\\n";
+    case "\r":
+      return "\\r";
+    case "	":
+      return "\\t";
+    case "\b":
+      return "\\b";
+    case "\f":
+      return "\\f";
+    case "\u2028":
+      return "\\u2028";
+    case "\u2029":
+      return "\\u2029";
+    default:
+      return char < " " ? `\\u${char.charCodeAt(0).toString(16).padStart(4, "0")}` : "";
+  }
+}
+function stringify_string(str) {
+  let result = "";
+  let last_pos = 0;
+  const len = str.length;
+  for (let i = 0; i < len; i += 1) {
+    const char = str[i];
+    const replacement = get_escaped_char(char);
+    if (replacement) {
+      result += str.slice(last_pos, i) + replacement;
+      last_pos = i + 1;
+    }
+  }
+  return `"${last_pos === 0 ? str : result + str.slice(last_pos)}"`;
+}
+function enumerable_symbols(object2) {
+  return Object.getOwnPropertySymbols(object2).filter((symbol2) => Object.getOwnPropertyDescriptor(object2, symbol2).enumerable);
+}
+function stringify_key(key) {
+  return is_identifier.test(key) ? "." + key : "[" + JSON.stringify(key) + "]";
+}
+function is_valid_array_index(n) {
+  if (!Number.isInteger(n)) return false;
+  if (n < 0) return false;
+  if (n > MAX_ARRAY_INDEX) return false;
+  return true;
+}
+function is_valid_array_len(n) {
+  if (!Number.isInteger(n)) return false;
+  if (n < 0) return false;
+  if (n > MAX_ARRAY_LEN) return false;
+  return true;
+}
+function is_valid_array_index_string(s) {
+  if (s.length === 0) return false;
+  if (s.length > 1 && s.charCodeAt(0) === 48) return false;
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (c < 48 || c > 57) return false;
+  }
+  return is_valid_array_index(+s);
+}
+function valid_array_indices(array2) {
+  const keys = Object.keys(array2);
+  for (var i = keys.length - 1; i >= 0; i--) {
+    if (is_valid_array_index_string(keys[i])) {
+      break;
+    }
+  }
+  keys.length = i + 1;
+  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"() {
+    "use strict";
+    init_constants();
+    DevalueError = class extends Error {
+      static {
+        __name(this, "DevalueError");
+      }
+      /**
+      * @param {string} message
+      * @param {string[]} keys
+      * @param {any} [value] - The value that failed to be serialized
+      * @param {any} [root] - The root value being serialized
+      */
+      constructor(message, keys, value, root) {
+        super(message);
+        this.name = "DevalueError";
+        this.path = keys.join("");
+        this.value = value;
+        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");
+    __name(get_escaped_char, "get_escaped_char");
+    __name(stringify_string, "stringify_string");
     __name(enumerable_symbols, "enumerable_symbols");
     is_identifier = /^[a-zA-Z_$][a-zA-Z_$0-9]*$/;
     __name(stringify_key, "stringify_key");
@@ -18331,7 +18976,7 @@ var init_devalue = __esm({
 });
 
 // ../core/dist/symbols.js
-var STABLE_ULID, STREAM_NAME_SYMBOL, STREAM_TYPE_SYMBOL, STREAM_FRAMING_SYMBOL, STREAM_SERVER_RUN_ID_SYMBOL, STREAM_SERVER_DEPLOYMENT_ID_SYMBOL, STREAM_WRITE_BATCH_SYMBOL, BODY_INIT_SYMBOL, WEBHOOK_RESPONSE_WRITABLE, WORKFLOW_CLASS_REGISTRY, ABORT_STREAM_NAME, ABORT_HOOK_TOKEN, ABORT_LISTENER_ATTACHED, ABORT_READER_CANCEL;
+var STABLE_ULID, STREAM_NAME_SYMBOL, STREAM_TYPE_SYMBOL, STREAM_FRAMING_SYMBOL, STREAM_SERVER_RUN_ID_SYMBOL, STREAM_SERVER_DEPLOYMENT_ID_SYMBOL, STREAM_SERVER_PUBLIC_KEY_SYMBOL, STREAM_DRAIN_SYMBOL, BODY_INIT_SYMBOL, WEBHOOK_RESPONSE_WRITABLE, WORKFLOW_CLASS_REGISTRY, ABORT_STREAM_NAME, ABORT_HOOK_TOKEN, ABORT_LISTENER_ATTACHED, ABORT_READER_CANCEL;
 var init_symbols = __esm({
   "../core/dist/symbols.js"() {
     "use strict";
@@ -18341,7 +18986,8 @@ var init_symbols = __esm({
     STREAM_FRAMING_SYMBOL = /* @__PURE__ */ Symbol.for("WORKFLOW_STREAM_FRAMING");
     STREAM_SERVER_RUN_ID_SYMBOL = /* @__PURE__ */ Symbol.for("WORKFLOW_STREAM_SERVER_RUN_ID");
     STREAM_SERVER_DEPLOYMENT_ID_SYMBOL = /* @__PURE__ */ Symbol.for("WORKFLOW_STREAM_SERVER_DEPLOYMENT_ID");
-    STREAM_WRITE_BATCH_SYMBOL = /* @__PURE__ */ Symbol.for("WORKFLOW_STREAM_WRITE_BATCH");
+    STREAM_SERVER_PUBLIC_KEY_SYMBOL = /* @__PURE__ */ Symbol.for("WORKFLOW_STREAM_SERVER_PUBLIC_KEY");
+    STREAM_DRAIN_SYMBOL = /* @__PURE__ */ Symbol.for("WORKFLOW_STREAM_DRAIN");
     BODY_INIT_SYMBOL = /* @__PURE__ */ Symbol.for("BODY_INIT");
     WEBHOOK_RESPONSE_WRITABLE = /* @__PURE__ */ Symbol.for("WEBHOOK_RESPONSE_WRITABLE");
     WORKFLOW_CLASS_REGISTRY = /* @__PURE__ */ Symbol.for("workflow-class-registry");
@@ -18394,6 +19040,14 @@ function isReadableUnlockedNotClosed(readable) {
   }
   return true;
 }
+function resolveAfterDrain(state) {
+  const barrier = state.drainBarrier;
+  if (!barrier) {
+    state.resolve();
+    return;
+  }
+  barrier().then(() => state.resolve(), (err) => state.reject(err));
+}
 function pollWritableLock(writable, state) {
   if (state.writablePollingInterval !== void 0) {
     return;
@@ -18406,9 +19060,9 @@ function pollWritableLock(writable, state) {
     }
     if (isWritableUnlockedNotClosed(writable) && state.pendingOps === 0) {
       state.doneResolved = true;
-      state.resolve();
       clearInterval(intervalId);
       state.writablePollingInterval = void 0;
+      resolveAfterDrain(state);
     }
   }, getLockPollIntervalMs());
   state.writablePollingInterval = intervalId;
@@ -18425,147 +19079,39 @@ function pollReadableLock(readable, state) {
     }
     if (isReadableUnlockedNotClosed(readable) && state.pendingOps === 0) {
       state.doneResolved = true;
-      state.resolve();
       clearInterval(intervalId);
       state.readablePollingInterval = void 0;
+      resolveAfterDrain(state);
     }
   }, getLockPollIntervalMs());
   state.readablePollingInterval = intervalId;
 }
-function flushablePipe(source, sink, state) {
-  const batchWrite = sink[STREAM_WRITE_BATCH_SYMBOL];
-  return typeof batchWrite === "function" ? flushablePipeCoalescing(source, sink, state, batchWrite) : flushablePipePerChunk(source, sink, state);
-}
-async function flushablePipePerChunk(source, sink, state) {
-  const reader = source.getReader();
-  const writer = sink.getWriter();
-  let cancelReason;
-  try {
-    while (true) {
-      if (state.streamEnded) {
-        return;
-      }
-      const readResult = await Promise.race([
-        reader.read(),
-        writer.closed.then(() => {
-          throw new WorkflowRuntimeError("Writable stream closed prematurely");
-        })
-      ]);
-      if (state.streamEnded) {
-        return;
-      }
-      if (readResult.done) {
-        state.streamEnded = true;
-        await writer.close();
-        if (!state.doneResolved) {
-          state.doneResolved = true;
-          state.resolve();
-        }
-        return;
-      }
-      state.pendingOps++;
-      try {
-        await writer.write(readResult.value);
-      } finally {
-        state.pendingOps--;
-      }
-    }
-  } catch (err) {
-    state.streamEnded = true;
-    cancelReason = err;
-    if (!state.doneResolved) {
-      state.doneResolved = true;
-      state.reject(err);
-    }
-    throw err;
-  } finally {
-    reader.cancel(cancelReason).catch(() => {
-    });
-    reader.releaseLock();
-    writer.releaseLock();
-  }
-}
-function wake(ctx, which) {
-  const resolve = ctx[which];
-  if (resolve) {
-    ctx[which] = null;
-    resolve();
-  }
-}
-function nextBatchSize(ctx) {
-  let count2 = 0;
-  let bytes = 0;
-  for (const chunk of ctx.queue) {
-    if (count2 >= ctx.maxChunksPerBatch) break;
-    if (count2 > 0 && bytes + chunk.byteLength > ctx.maxBytesPerBatch) break;
-    count2++;
-    bytes += chunk.byteLength;
-  }
-  return count2;
-}
-async function drainBatches(ctx) {
-  while (true) {
-    if (ctx.queue.length === 0) {
-      if (ctx.sourceDone) return;
-      await new Promise((resolve) => {
-        ctx.wakeConsumer = resolve;
-      });
-      continue;
-    }
-    const count2 = nextBatchSize(ctx);
-    const batch = ctx.queue.slice(0, count2);
-    ctx.queue = ctx.queue.slice(count2);
-    await ctx.batchWrite(batch);
-    ctx.state.pendingOps -= batch.length;
-    wake(ctx, "wakeProducer");
-  }
-}
-function readNextChunk(reader, writer, consumer) {
-  return Promise.race([
-    reader.read(),
-    writer.closed.then(() => {
-      throw new WorkflowRuntimeError("Writable stream closed prematurely");
-    }),
-    consumer.then(() => {
-      throw new WorkflowRuntimeError("Stream consumer ended prematurely");
-    }, (err) => {
-      throw err;
-    })
-  ]);
-}
-async function awaitBackpressureRelief(ctx, consumer, maxInflight) {
-  if (ctx.state.pendingOps < maxInflight) return;
-  await Promise.race([
-    new Promise((resolve) => {
-      ctx.wakeProducer = resolve;
-    }),
-    consumer.then(() => void 0, () => void 0)
-  ]);
+function flushablePipe(source, sink, state) {
+  const drain = sink[STREAM_DRAIN_SYMBOL];
+  if (typeof drain === "function") {
+    state.drainBarrier = drain;
+  }
+  return flushablePipePerChunk(source, sink, state);
 }
-async function flushablePipeCoalescing(source, sink, state, batchWrite) {
+async function flushablePipePerChunk(source, sink, state) {
   const reader = source.getReader();
   const writer = sink.getWriter();
-  const maxInflight = getMaxInflightChunks();
   let cancelReason;
-  const ctx = {
-    state,
-    batchWrite,
-    queue: [],
-    sourceDone: false,
-    wakeConsumer: null,
-    wakeProducer: null,
-    maxChunksPerBatch: getMaxChunksPerBatch(),
-    maxBytesPerBatch: getMaxBytesPerBatch()
-  };
-  const consumer = drainBatches(ctx);
   try {
-    while (!state.streamEnded) {
-      const readResult = await readNextChunk(reader, writer, consumer);
-      if (state.streamEnded) return;
+    while (true) {
+      if (state.streamEnded) {
+        return;
+      }
+      const readResult = await Promise.race([
+        reader.read(),
+        writer.closed.then(() => {
+          throw new WorkflowRuntimeError("Writable stream closed prematurely");
+        })
+      ]);
+      if (state.streamEnded) {
+        return;
+      }
       if (readResult.done) {
-        ctx.sourceDone = true;
-        wake(ctx, "wakeConsumer");
-        await consumer;
         state.streamEnded = true;
         await writer.close();
         if (!state.doneResolved) {
@@ -18574,18 +19120,20 @@ async function flushablePipeCoalescing(source, sink, state, batchWrite) {
         }
         return;
       }
-      ctx.queue.push(readResult.value);
       state.pendingOps++;
-      wake(ctx, "wakeConsumer");
-      await awaitBackpressureRelief(ctx, consumer, maxInflight);
+      try {
+        await writer.write(readResult.value);
+      } finally {
+        state.pendingOps--;
+      }
     }
   } catch (err) {
     state.streamEnded = true;
     cancelReason = err;
-    ctx.sourceDone = true;
-    wake(ctx, "wakeConsumer");
-    await consumer.catch(() => {
-    });
+    if (state.drainBarrier) {
+      await state.drainBarrier().catch(() => {
+      });
+    }
     if (!state.doneResolved) {
       state.doneResolved = true;
       state.reject(err);
@@ -18598,7 +19146,7 @@ async function flushablePipeCoalescing(source, sink, state, batchWrite) {
     writer.releaseLock();
   }
 }
-var MAX_INFLIGHT_CHUNKS, getMaxInflightChunks, MAX_CHUNKS_PER_BATCH, getMaxChunksPerBatch, MAX_BYTES_PER_BATCH, getMaxBytesPerBatch, LOCK_POLL_INTERVAL_MS, getLockPollIntervalMs;
+var MAX_INFLIGHT_CHUNKS, getMaxInflightChunks, MAX_CHUNKS_PER_BATCH, getMaxChunksPerBatch, MAX_BYTES_PER_BATCH, getMaxBytesPerBatch, MAX_BUFFERED_BYTES, getMaxBufferedBytes, LOCK_POLL_INTERVAL_MS, getLockPollIntervalMs;
 var init_flushable_stream = __esm({
   "../core/dist/flushable-stream.js"() {
     "use strict";
@@ -18621,6 +19169,11 @@ var init_flushable_stream = __esm({
       integer: true,
       min: 1
     }), "getMaxBytesPerBatch");
+    MAX_BUFFERED_BYTES = 8 * 1024 * 1024;
+    getMaxBufferedBytes = /* @__PURE__ */ __name(() => envNumber("WORKFLOW_STREAM_MAX_BUFFERED_BYTES", MAX_BUFFERED_BYTES, {
+      integer: true,
+      min: 1
+    }), "getMaxBufferedBytes");
     LOCK_POLL_INTERVAL_MS = 10;
     getLockPollIntervalMs = /* @__PURE__ */ __name(() => envNumber("WORKFLOW_LOCK_POLL_INTERVAL_MS", LOCK_POLL_INTERVAL_MS, {
       integer: true,
@@ -18629,16 +19182,11 @@ var init_flushable_stream = __esm({
     __name(createFlushableState, "createFlushableState");
     __name(isWritableUnlockedNotClosed, "isWritableUnlockedNotClosed");
     __name(isReadableUnlockedNotClosed, "isReadableUnlockedNotClosed");
+    __name(resolveAfterDrain, "resolveAfterDrain");
     __name(pollWritableLock, "pollWritableLock");
     __name(pollReadableLock, "pollReadableLock");
     __name(flushablePipe, "flushablePipe");
     __name(flushablePipePerChunk, "flushablePipePerChunk");
-    __name(wake, "wake");
-    __name(nextBatchSize, "nextBatchSize");
-    __name(drainBatches, "drainBatches");
-    __name(readNextChunk, "readNextChunk");
-    __name(awaitBackpressureRelief, "awaitBackpressureRelief");
-    __name(flushablePipeCoalescing, "flushablePipeCoalescing");
   }
 });
 
@@ -19234,28 +19782,6 @@ var init_step_function = __esm({
   }
 });
 
-// ../core/dist/serialization/types.js
-function isFormatPrefix(value) {
-  return value.length === 4 && /^[a-z0-9]{4}$/.test(value);
-}
-var SerializationFormat;
-var init_types = __esm({
-  "../core/dist/serialization/types.js"() {
-    "use strict";
-    __name(isFormatPrefix, "isFormatPrefix");
-    SerializationFormat = {
-      /** devalue stringify/parse with TextEncoder/TextDecoder */
-      DEVALUE_V1: "devl",
-      /** Encrypted payload (inner payload has its own format prefix) */
-      ENCRYPTED: "encr",
-      /** Gzip-compressed payload (inner payload has its own format prefix) */
-      GZIP: "gzip",
-      /** Zstandard-compressed payload (inner payload has its own format prefix) */
-      ZSTD: "zstd"
-    };
-  }
-});
-
 // ../core/dist/serialization/codec-devalue.js
 function getReducersForMode(mode, global2 = globalThis, extraReducers) {
   let base;
@@ -19355,60 +19881,6 @@ var init_codec_devalue = __esm({
   }
 });
 
-// ../core/dist/serialization/format.js
-function encodeWithFormatPrefix(format, payload) {
-  if (!(payload instanceof Uint8Array)) {
-    return payload;
-  }
-  const prefixBytes = formatEncoder.encode(format);
-  const result = new Uint8Array(FORMAT_PREFIX_LENGTH + payload.length);
-  result.set(prefixBytes, 0);
-  result.set(payload, FORMAT_PREFIX_LENGTH);
-  return result;
-}
-function peekFormatPrefix(data) {
-  if (!(data instanceof Uint8Array) || data.length < FORMAT_PREFIX_LENGTH) {
-    return null;
-  }
-  const prefixBytes = data.subarray(0, FORMAT_PREFIX_LENGTH);
-  const str = formatDecoder.decode(prefixBytes);
-  return isFormatPrefix(str) ? str : null;
-}
-function decodeFormatPrefix(data) {
-  if (!(data instanceof Uint8Array)) {
-    return {
-      format: SerializationFormat.DEVALUE_V1,
-      payload: new TextEncoder().encode(JSON.stringify(data))
-    };
-  }
-  if (data.length < FORMAT_PREFIX_LENGTH) {
-    throw new Error(`Data too short to contain format prefix: expected at least ${FORMAT_PREFIX_LENGTH} bytes, got ${data.length}`);
-  }
-  const prefixBytes = data.subarray(0, FORMAT_PREFIX_LENGTH);
-  const str = formatDecoder.decode(prefixBytes);
-  if (!isFormatPrefix(str)) {
-    throw new Error(`Invalid format prefix: "${str}". Must be 4 characters of [a-z0-9].`);
-  }
-  const payload = data.subarray(FORMAT_PREFIX_LENGTH);
-  return {
-    format: str,
-    payload
-  };
-}
-var FORMAT_PREFIX_LENGTH, formatEncoder, formatDecoder;
-var init_format = __esm({
-  "../core/dist/serialization/format.js"() {
-    "use strict";
-    init_types();
-    FORMAT_PREFIX_LENGTH = 4;
-    formatEncoder = new TextEncoder();
-    formatDecoder = new TextDecoder();
-    __name(encodeWithFormatPrefix, "encodeWithFormatPrefix");
-    __name(peekFormatPrefix, "peekFormatPrefix");
-    __name(decodeFormatPrefix, "decodeFormatPrefix");
-  }
-});
-
 // ../core/dist/serialization/compression.js
 function isCompressionDisabledByEnv() {
   try {
@@ -19568,51 +20040,6 @@ var init_compression = __esm({
   }
 });
 
-// ../core/dist/serialization/encryption.js
-async function resolveEncryptionKey(key) {
-  return typeof key === "function" ? key() : key;
-}
-async function encrypt2(data, key) {
-  if (!key || !(data instanceof Uint8Array)) return data;
-  const encrypted = await encrypt(key, data);
-  return encodeWithFormatPrefix(SerializationFormat.ENCRYPTED, encrypted);
-}
-async function decrypt2(data, key) {
-  if (!(data instanceof Uint8Array)) return data;
-  const format = peekFormatPrefix(data);
-  if (format === SerializationFormat.ENCRYPTED && !key) {
-    throw new RuntimeDecryptionError("Encrypted data encountered but no encryption key is available. Encryption is not configured or no key was provided for this run.", {
-      context: {
-        operation: "decrypt",
-        byteLength: data.byteLength,
-        formatPrefix: "encr"
-      }
-    });
-  }
-  if (format !== SerializationFormat.ENCRYPTED) return data;
-  const { payload } = decodeFormatPrefix(data);
-  try {
-    return await decrypt(key, payload);
-  } catch (error48) {
-    if (RuntimeDecryptionError.is(error48) && error48.context) {
-      error48.context.formatPrefix = format;
-    }
-    throw error48;
-  }
-}
-var init_encryption2 = __esm({
-  "../core/dist/serialization/encryption.js"() {
-    "use strict";
-    init_dist2();
-    init_encryption();
-    init_format();
-    init_types();
-    __name(resolveEncryptionKey, "resolveEncryptionKey");
-    __name(encrypt2, "encrypt");
-    __name(decrypt2, "decrypt");
-  }
-});
-
 // ../errors/dist/internal-chalk.js
 var colorEnabled, sgr, chalk, internal_chalk_default;
 var init_internal_chalk = __esm({
@@ -19625,7 +20052,7 @@ var init_internal_chalk = __esm({
       if (p.env.NO_COLOR) return false;
       return Boolean(p.stdout?.isTTY);
     })();
-    sgr = /* @__PURE__ */ __name((open, close) => (s) => colorEnabled ? `\x1B[${open}m${s}\x1B[${close}m` : s, "sgr");
+    sgr = /* @__PURE__ */ __name((open2, close) => (s) => colorEnabled ? `\x1B[${open2}m${s}\x1B[${close}m` : s, "sgr");
     chalk = {
       bold: sgr(1, 22),
       dim: sgr(2, 22),
@@ -22540,6 +22967,7 @@ var init_abort_controller = __esm({
     "use strict";
     init_dist2();
     init_events_consumer();
+    init_private();
     init_serialization2();
     init_symbols();
     init_util2();
@@ -24620,6 +25048,15 @@ var init_capabilities = __esm({
       {
         format: SerializationFormat.ZSTD,
         minVersion: "5.0.0-beta.18"
+      },
+      // TODO(release): verify this matches the actual version that ships sealed-box
+      // encryption. If a "Version Packages (beta)" PR merges before this change,
+      // bump to the next beta. Unlike the entries above, a wrong cutoff here is
+      // not a correctness hazard: producers gate `encp` on the target run carrying
+      // an `encryptionPublicKey`, not on this table (see History above).
+      {
+        format: SerializationFormat.SEALED,
+        minVersion: "5.0.0-beta.37"
       }
     ];
     CAPABILITY_VERSION_TABLE = [
@@ -24640,7 +25077,7 @@ var version2;
 var init_version = __esm({
   "../core/dist/version.js"() {
     "use strict";
-    version2 = "5.0.0-beta.36";
+    version2 = "5.0.0-beta.37";
   }
 });
 
@@ -24726,18 +25163,24 @@ function parseHealthCheckResponse(chunks) {
   if (typeof r.workflowCoreVersion === "string") {
     parsed.workflowCoreVersion = r.workflowCoreVersion;
   }
+  if (typeof r.encryptionPublicKey === "string") {
+    parsed.encryptionPublicKey = r.encryptionPublicKey;
+  }
   return parsed;
 }
-async function healthCheck(world, endpoint, options) {
+async function healthCheck(world, options) {
   const timeout = options?.timeout ?? DEFAULT_HEALTH_CHECK_TIMEOUT;
   const correlationId = world.createRunId?.() ?? generateId();
   const streamName = getHealthCheckStreamName(correlationId);
-  const queueName = `${getQueueTopicPrefix(endpoint, resolveQueueNamespace(options?.namespace))}health_check`;
+  const queueName = `${getQueueTopicPrefix("workflow", resolveQueueNamespace(options?.namespace))}health_check`;
   const startTime = Date.now();
   try {
     await world.queue(queueName, {
       __healthCheck: true,
-      correlationId
+      correlationId,
+      ...options?.runId ? {
+        runId: options.runId
+      } : {}
     }, {
       // Use JSON transport so the health check works against both
       // old (JSON-only) and new (dual) deployments.
@@ -24788,8 +25231,9 @@ var init_helpers = __esm({
     init_dist2();
     init_dist4();
     init_node();
-    init_encryption();
     init_logger();
+    init_sealed_box();
+    init_encryption2();
     init_semantic_conventions();
     init_telemetry();
     init_version();
@@ -25981,20 +26425,49 @@ __export(resume_hook_exports, {
   resumeHook: () => resumeHook,
   resumeWebhook: () => resumeWebhook
 });
-async function getHookAndRun(token) {
-  const world = await getWorldLazy();
-  const hook = await world.hooks.getByToken(token);
-  const run2 = await world.runs.get(hook.runId);
+function resumeContextFromRun(run2) {
+  const coreVersion = run2.executionContext?.workflowCoreVersion;
+  const traceCarrier = run2.executionContext?.traceCarrier;
   return {
-    hook,
+    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
+  };
+}
+async function resolveHookResumeInfo(hook) {
+  if (hook.resumeContext) {
+    return {
+      resumeContext: hook.resumeContext,
+      source: "hook"
+    };
+  }
+  const run2 = await (await getWorldLazy()).runs.get(hook.runId);
+  return {
+    resumeContext: resumeContextFromRun(run2),
+    source: "run_fallback",
     run: run2
   };
 }
+async function resolveHookEncryptionKey(hook, info) {
+  const world = await getWorldLazy();
+  const rawKey = info.run ? await world.getEncryptionKeyForRun?.(info.run) : await world.getEncryptionKeyForRun?.(hook.runId, {
+    deploymentId: info.resumeContext.deploymentId
+  });
+  return rawKey ? await importKey(rawKey) : void 0;
+}
 async function getHookByTokenWithKey(token) {
-  const { hook, run: run2 } = await getHookAndRun(token);
-  const rawKey = await (await getWorldLazy()).getEncryptionKeyForRun?.(run2);
-  const encryptionKey = rawKey ? await importKey(rawKey) : void 0;
+  const world = await getWorldLazy();
+  const hook = await world.hooks.getByToken(token);
+  let encryptionKey;
   if (typeof hook.metadata !== "undefined") {
+    const info = await resolveHookResumeInfo(hook);
+    const rawKey = info.run ? await world.getEncryptionKeyForRun?.(info.run) : await world.getEncryptionKeyForRun?.(hook.runId, {
+      deploymentId: info.resumeContext.deploymentId
+    });
+    encryptionKey = rawKey ? await deriveRunPayloadKeys(rawKey) : void 0;
     hook.metadata = await hydrateStepArguments(hook.metadata, hook.runId, encryptionKey);
   }
   return {
@@ -26011,38 +26484,38 @@ async function resumeHook(tokenOrHook, payload, encryptionKeyOverride) {
     return trace("hook.resume", async (span) => {
       const world = await getWorldLazy();
       try {
-        let hook;
-        let workflowRun;
-        if (typeof tokenOrHook === "string") {
-          const result = await getHookAndRun(tokenOrHook);
-          hook = result.hook;
-          workflowRun = result.run;
-        } else {
-          hook = tokenOrHook;
-          workflowRun = await world.runs.get(hook.runId);
-        }
+        const hook = typeof tokenOrHook === "string" ? await world.hooks.getByToken(tokenOrHook) : tokenOrHook;
+        const info = await resolveHookResumeInfo(hook);
+        const { resumeContext } = info;
         span?.setAttributes({
           ...HookToken(hook.token),
           ...HookId(hook.hookId),
-          ...WorkflowRunId(hook.runId)
+          ...WorkflowRunId(hook.runId),
+          "workflow.hook.resume_context_source": info.source
         });
-        if (isTerminalWorkflowRunStatus(workflowRun.status)) {
+        if (info.run && isTerminalWorkflowRunStatus(info.run.status)) {
           throw new HookNotFoundError(hook.token);
         }
-        let encryptionKey = encryptionKeyOverride;
-        if (!encryptionKey) {
-          const rawKey = await world.getEncryptionKeyForRun?.(workflowRun);
-          encryptionKey = rawKey ? await importKey(rawKey) : void 0;
-        }
-        const rawVersion = workflowRun.executionContext?.workflowCoreVersion;
-        const capabilities = getRunCapabilities(typeof rawVersion === "string" ? rawVersion : void 0);
-        if (!capabilities.supportedFormats.has(SerializationFormat.ENCRYPTED)) {
-          encryptionKey = void 0;
+        const capabilities = getRunCapabilities(resumeContext.workflowCoreVersion);
+        let payloadKey;
+        const runPublicKey = encryptionKeyOverride ? (
+          // hydrate hook metadata), so sealing would add an ECDH for no
+          // saved round trip. Reuse what it resolved.
+          void 0
+        ) : decodeRunPublicKey(resumeContext.encryptionPublicKey);
+        if (runPublicKey) {
+          payloadKey = sealTo(runPublicKey);
+        } else {
+          let encryptionKey = encryptionKeyOverride ?? await resolveHookEncryptionKey(hook, info);
+          if (!capabilities.supportedFormats.has(SerializationFormat.ENCRYPTED)) {
+            encryptionKey = void 0;
+          }
+          payloadKey = encryptionKey;
         }
-        const compression = (workflowRun.specVersion ?? 0) >= SPEC_VERSION_SUPPORTS_COMPRESSION && capabilities.supportedFormats.has(SerializationFormat.GZIP);
+        const compression = (resumeContext.runSpecVersion ?? 0) >= SPEC_VERSION_SUPPORTS_COMPRESSION && capabilities.supportedFormats.has(SerializationFormat.GZIP);
         const ops = [];
         const v1Compat = isLegacySpecVersion(hook.specVersion);
-        const dehydratedPayload = await dehydrateStepReturnValue(payload, hook.runId, encryptionKey, ops, globalThis, v1Compat, capabilities.framedByteStreams, compression);
+        const dehydratedPayload = await dehydrateStepReturnValue(payload, hook.runId, payloadKey, ops, globalThis, v1Compat, capabilities.framedByteStreams, compression);
         safeWaitUntil(Promise.all(ops), (err) => {
           if (err === void 0) return;
           runtimeLogger.warn("Background flush of hook payload ops failed", {
@@ -26051,33 +26524,40 @@ async function resumeHook(tokenOrHook, payload, encryptionKeyOverride) {
             error: err instanceof Error ? err.message : String(err)
           });
         });
-        await world.events.create(hook.runId, {
-          eventType: "hook_received",
-          specVersion: SPEC_VERSION_CURRENT,
-          correlationId: hook.hookId,
-          eventData: {
-            ...v1Compat ? {} : {
-              token: hook.token
-            },
-            payload: dehydratedPayload
+        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);
           }
-        }, {
-          v1Compat
-        });
+          throw err;
+        }
         span?.setAttributes({
-          ...WorkflowName(workflowRun.workflowName)
+          ...WorkflowName(resumeContext.workflowName)
         });
-        const originLink = await linkToTraceCarrier(workflowRun.executionContext?.traceCarrier);
+        const originLink = await linkToTraceCarrier(resumeContext.traceCarrier);
         if (originLink) {
           span?.addLink?.(originLink);
         }
-        await world.queue(getWorkflowQueueName(workflowRun.workflowName), {
+        await world.queue(getWorkflowQueueName(resumeContext.workflowName), {
           runId: hook.runId,
-          // attach the trace carrier from the workflow run
-          traceCarrier: workflowRun.executionContext?.traceCarrier ?? void 0
+          // attach the trace carrier from the run's resume context
+          traceCarrier: resumeContext.traceCarrier ?? void 0
         }, {
-          deploymentId: workflowRun.deploymentId,
-          specVersion: workflowRun.specVersion ?? SPEC_VERSION_LEGACY
+          deploymentId: resumeContext.deploymentId,
+          specVersion: resumeContext.runSpecVersion ?? SPEC_VERSION_LEGACY
         });
         return hook;
       } catch (err) {
@@ -26138,6 +26618,8 @@ var init_resume_hook = __esm({
     init_capabilities();
     init_encryption();
     init_logger();
+    init_sealed_box();
+    init_encryption2();
     init_serialization2();
     init_symbols();
     init_semantic_conventions();
@@ -26145,7 +26627,9 @@ var init_resume_hook = __esm({
     init_get_world_lazy();
     init_helpers();
     init_wait_until();
-    __name(getHookAndRun, "getHookAndRun");
+    __name(resumeContextFromRun, "resumeContextFromRun");
+    __name(resolveHookResumeInfo, "resolveHookResumeInfo");
+    __name(resolveHookEncryptionKey, "resolveHookEncryptionKey");
     __name(getHookByTokenWithKey, "getHookByTokenWithKey");
     __name(getHookByToken, "getHookByToken");
     __name(resumeHook, "resumeHook");
@@ -26198,19 +26682,24 @@ function getSerializeStream(reducers, cryptoKey) {
     resolved: false,
     key: void 0
   };
+  let sealSession;
   const stream = new TransformStream({
     async transform(chunk, controller) {
       try {
         if (!keyState.resolved) {
           keyState.key = await resolveEncryptionKey(cryptoKey);
           keyState.resolved = true;
+          if (isSealTarget(keyState.key)) {
+            sealSession = createSealSession(keyState.key.recipientPublicKey, keyState.key.aad);
+          }
         }
         const serialized = stringify(chunk, reducers);
         const payload = encoder2.encode(serialized);
         let prefixed = encodeWithFormatPrefix(SerializationFormat.DEVALUE_V1, payload);
-        if (keyState.key) {
-          const encrypted = await encrypt(keyState.key, prefixed);
-          prefixed = encodeWithFormatPrefix(SerializationFormat.ENCRYPTED, encrypted);
+        if (sealSession) {
+          prefixed = encodeWithFormatPrefix(SerializationFormat.SEALED, await sealSession.seal(prefixed));
+        } else if (keyState.key) {
+          prefixed = await encrypt2(prefixed, keyState.key);
         }
         const frame2 = new Uint8Array(FRAME_HEADER_SIZE + prefixed.length);
         new DataView(frame2.buffer).setUint32(0, prefixed.length, false);
@@ -26238,6 +26727,7 @@ function getDeserializeStream(revivers, cryptoKey) {
     resolved: false,
     key: void 0
   };
+  let openSession;
   function appendToBuffer(data) {
     const newBuffer = new Uint8Array(buffer2.length + data.length);
     newBuffer.set(buffer2, 0);
@@ -26249,6 +26739,9 @@ function getDeserializeStream(revivers, cryptoKey) {
     if (!keyState.resolved) {
       keyState.key = await resolveEncryptionKey(cryptoKey);
       keyState.resolved = true;
+      if (isRunPayloadKeys(keyState.key)) {
+        openSession = createOpenSession(keyState.key.keyPair, keyState.key.aad);
+      }
     }
     while (buffer2.length >= FRAME_HEADER_SIZE) {
       const frameLength = new DataView(buffer2.buffer, buffer2.byteOffset, buffer2.byteLength).getUint32(0, false);
@@ -26258,20 +26751,22 @@ function getDeserializeStream(revivers, cryptoKey) {
       const frameData = buffer2.slice(FRAME_HEADER_SIZE, FRAME_HEADER_SIZE + frameLength);
       buffer2 = buffer2.slice(FRAME_HEADER_SIZE + frameLength);
       let { format, payload } = decodeFormatPrefix(frameData);
-      if (format === SerializationFormat.ENCRYPTED) {
-        if (!keyState.key) {
-          controller.error(new RuntimeDecryptionError("Encrypted stream data encountered but no encryption key is available. Encryption is not configured or no key was provided for this run.", {
+      if (format === SerializationFormat.ENCRYPTED || format === SerializationFormat.SEALED) {
+        const sealed = format === SerializationFormat.SEALED;
+        const usable = sealed ? isRunPayloadKeys(keyState.key) : aesKeyOf(keyState.key) !== void 0;
+        if (!usable) {
+          controller.error(new RuntimeDecryptionError(sealed ? "Sealed stream data encountered but no run keypair is available. Opening a sealed frame requires the run's own encryption key material." : "Encrypted stream data encountered but no encryption key is available. Encryption is not configured or no key was provided for this run.", {
             context: {
               operation: "decrypt",
               byteLength: payload.byteLength,
-              formatPrefix: "encr"
+              formatPrefix: sealed ? "encp" : "encr"
             }
           }));
           return;
         }
         let decrypted;
         try {
-          decrypted = await decrypt(keyState.key, payload);
+          decrypted = sealed ? await openSession.open(decodeFormatPrefix(frameData).payload) : await decrypt2(frameData, keyState.key);
         } catch (error48) {
           if (RuntimeDecryptionError.is(error48) && error48.context) {
             error48.context.formatPrefix = format;
@@ -26699,6 +27194,10 @@ function getExternalReducers(global2 = globalThis, ops, runId, cryptoKey, framed
           name: existingName,
           runId: existingRunId
         };
+        const existingPublicKey = value[STREAM_SERVER_PUBLIC_KEY_SYMBOL];
+        if (typeof existingPublicKey === "string") {
+          descriptor.encryptionPublicKey = existingPublicKey;
+        }
         const existingDeploymentId = value[STREAM_SERVER_DEPLOYMENT_ID_SYMBOL];
         if (typeof existingDeploymentId === "string") {
           descriptor.deploymentId = existingDeploymentId;
@@ -26764,6 +27263,10 @@ function getWorkflowReducers(global2 = globalThis) {
       if (typeof foreignDeploymentId === "string") {
         s.deploymentId = foreignDeploymentId;
       }
+      const foreignPublicKey = value[STREAM_SERVER_PUBLIC_KEY_SYMBOL];
+      if (typeof foreignPublicKey === "string") {
+        s.encryptionPublicKey = foreignPublicKey;
+      }
       return s;
     }, "WritableStream"),
     // AbortController/AbortSignal in workflow context — just read symbols (handles).
@@ -26836,6 +27339,10 @@ function getStepReducers(global2 = globalThis, ops, runId, cryptoKey, framedByte
         name
       };
       if (typeof foreignRunId === "string") s.runId = foreignRunId;
+      const foreignPublicKey = value[STREAM_SERVER_PUBLIC_KEY_SYMBOL];
+      if (typeof foreignPublicKey === "string") {
+        s.encryptionPublicKey = foreignPublicKey;
+      }
       const foreignDeploymentId = value[STREAM_SERVER_DEPLOYMENT_ID_SYMBOL];
       if (typeof foreignDeploymentId === "string") {
         s.deploymentId = foreignDeploymentId;
@@ -26988,7 +27495,9 @@ function getCommonRevivers2(global2 = globalThis) {
     ...getCommonRevivers(global2)
   };
 }
-async function getForwardedWritableEncryptionKey(runId, deploymentId) {
+async function getForwardedWritableEncryptionKey(runId, deploymentId, encryptionPublicKey) {
+  const ownerPublicKey = decodeRunPublicKey(encryptionPublicKey);
+  if (ownerPublicKey) return sealTo(ownerPublicKey);
   const world = await getWorldLazy();
   if (!world.getEncryptionKeyForRun) return void 0;
   const rawKey = deploymentId ? await world.getEncryptionKeyForRun(runId, {
@@ -27061,7 +27570,7 @@ function getExternalRevivers(global2 = globalThis, ops, runId, cryptoKey) {
     }, "ReadableStream"),
     WritableStream: /* @__PURE__ */ __name((value) => {
       const targetRunId = typeof value.runId === "string" ? value.runId : runId;
-      const targetKey = targetRunId === runId ? cryptoKey : getForwardedWritableEncryptionKey(targetRunId, value.deploymentId);
+      const targetKey = targetRunId === runId ? cryptoKey : getForwardedWritableEncryptionKey(targetRunId, value.deploymentId, value.encryptionPublicKey);
       const serialize3 = getSerializeStream(getExternalReducers(global2, ops, targetRunId, targetKey), targetKey);
       const serverWritable = new WorkflowServerWritableStream(targetRunId, value.name);
       const state = createFlushableState();
@@ -27083,6 +27592,12 @@ function getExternalRevivers(global2 = globalThis, ops, runId, cryptoKey) {
           writable: false
         });
       }
+      if (typeof value.encryptionPublicKey === "string") {
+        Object.defineProperty(serialize3.writable, STREAM_SERVER_PUBLIC_KEY_SYMBOL, {
+          value: value.encryptionPublicKey,
+          writable: false
+        });
+      }
       return serialize3.writable;
     }, "WritableStream"),
     AbortController: /* @__PURE__ */ __name((value) => reviveAbortController(value, ops, runId), "AbortController"),
@@ -27220,7 +27735,7 @@ function getStepRevivers(global2 = globalThis, ops, runId, cryptoKey, deployment
     WritableStream: /* @__PURE__ */ __name((value) => {
       const targetRunId = typeof value.runId === "string" ? value.runId : runId;
       const targetDeploymentId = typeof value.deploymentId === "string" ? value.deploymentId : targetRunId === runId ? deploymentId : void 0;
-      const targetKey = targetRunId === runId ? cryptoKey : getForwardedWritableEncryptionKey(targetRunId, targetDeploymentId);
+      const targetKey = targetRunId === runId ? cryptoKey : getForwardedWritableEncryptionKey(targetRunId, targetDeploymentId, value.encryptionPublicKey);
       const serialize3 = getSerializeStream(getStepReducers(global2, ops, targetRunId, targetKey), targetKey);
       const serverWritable = new WorkflowServerWritableStream(targetRunId, value.name);
       const state = createFlushableState();
@@ -27242,6 +27757,18 @@ function getStepRevivers(global2 = globalThis, ops, runId, cryptoKey, deployment
           writable: false
         });
       }
+      if (typeof value.encryptionPublicKey !== "string" && targetRunId === runId && isRunPayloadKeys(cryptoKey)) {
+        Object.defineProperty(serialize3.writable, STREAM_SERVER_PUBLIC_KEY_SYMBOL, {
+          value: bytesToBase64(cryptoKey.keyPair.publicKey),
+          writable: false
+        });
+      }
+      if (typeof value.encryptionPublicKey === "string") {
+        Object.defineProperty(serialize3.writable, STREAM_SERVER_PUBLIC_KEY_SYMBOL, {
+          value: value.encryptionPublicKey,
+          writable: false
+        });
+      }
       return serialize3.writable;
     }, "WritableStream"),
     AbortController: /* @__PURE__ */ __name((value) => reviveAbortController(value, ops, runId), "AbortController"),
@@ -27384,7 +27911,7 @@ function getStreamAndRequestRevivers(allRevivers) {
   }
   return extra;
 }
-var defaultUlid, FRAME_HEADER_SIZE, MAX_FRAME_SIZE, WorkflowServerReadableStream, FRAMED_STREAM_MAX_RECONNECTS, getFramedStreamMaxReconnects, FRAMED_STREAM_MAX_TOTAL_RECONNECTS, getFramedStreamMaxTotalReconnects, STREAM_FLUSH_INTERVAL_MS, getStreamFlushIntervalMs, WorkflowServerWritableStream, STREAM_AND_REQUEST_KEYS;
+var defaultUlid, FRAME_HEADER_SIZE, MAX_FRAME_SIZE, WorkflowServerReadableStream, FRAMED_STREAM_MAX_RECONNECTS, getFramedStreamMaxReconnects, FRAMED_STREAM_MAX_TOTAL_RECONNECTS, getFramedStreamMaxTotalReconnects, STREAM_FLUSH_INTERVAL_MS, getEnvStreamFlushIntervalMs, WorkflowServerWritableStream, STREAM_AND_REQUEST_KEYS;
 var init_serialization2 = __esm({
   "../core/dist/serialization.js"() {
     "use strict";
@@ -27392,10 +27919,12 @@ var init_serialization2 = __esm({
     init_dist4();
     init_devalue();
     init_node();
+    init_sealed_box();
     init_encryption();
     init_flushable_stream();
     init_private();
     init_get_world_lazy();
+    init_sealed_box();
     init_client();
     init_compression();
     init_encryption2();
@@ -27494,10 +28023,13 @@ var init_serialization2 = __esm({
       min: 1
     }), "getFramedStreamMaxTotalReconnects");
     __name(createReconnectingFramedStream, "createReconnectingFramedStream");
-    STREAM_FLUSH_INTERVAL_MS = 10;
-    getStreamFlushIntervalMs = /* @__PURE__ */ __name(() => envNumber("WORKFLOW_STREAM_FLUSH_INTERVAL_MS", STREAM_FLUSH_INTERVAL_MS, {
-      integer: true
-    }), "getStreamFlushIntervalMs");
+    STREAM_FLUSH_INTERVAL_MS = 0;
+    getEnvStreamFlushIntervalMs = /* @__PURE__ */ __name(() => {
+      const value = envNumber("WORKFLOW_STREAM_FLUSH_INTERVAL_MS", Number.NaN, {
+        integer: true
+      });
+      return Number.isNaN(value) ? void 0 : value;
+    }, "getEnvStreamFlushIntervalMs");
     __name(recordStreamWriteFlush, "recordStreamWriteFlush");
     __name(recordStreamClose, "recordStreamClose");
     WorkflowServerWritableStream = class extends WritableStream {
@@ -27532,106 +28064,189 @@ var init_serialization2 = __esm({
           }
         }, "ensureRunReady");
         let buffer2 = [];
+        let bufferBytes = 0;
+        let inFlightChunks = 0;
+        let inFlightBytes = 0;
         let flushTimer = null;
-        let flushPromise = null;
-        let resolvedFlushIntervalMs;
-        let batchStartAt;
-        const flush = /* @__PURE__ */ __name(async () => {
-          if (flushTimer) {
-            clearTimeout(flushTimer);
-            flushTimer = null;
-          }
-          if (buffer2.length === 0) return;
+        let inFlight = null;
+        let sinkError;
+        let resolvedFlushIntervalMs = getEnvStreamFlushIntervalMs();
+        let flushIntervalResolution = null;
+        const maxChunksPerRequest = getMaxChunksPerBatch();
+        const maxBytesPerRequest = getMaxBytesPerBatch();
+        const maxBufferedChunks = getMaxInflightChunks();
+        const maxBufferedBytes = getMaxBufferedBytes();
+        let bufferT0;
+        let capacityWaiters = [];
+        let drainWaiters = [];
+        const rejectWaiters = /* @__PURE__ */ __name((err) => {
+          const all = [
+            ...capacityWaiters,
+            ...drainWaiters
+          ];
+          capacityWaiters = [];
+          drainWaiters = [];
+          for (const w of all) w.reject(err);
+        }, "rejectWaiters");
+        const takeGroup = /* @__PURE__ */ __name(() => {
+          let count2 = 0;
+          let bytes = 0;
+          for (const chunk of buffer2) {
+            if (count2 >= maxChunksPerRequest) break;
+            if (count2 > 0 && bytes + chunk.byteLength > maxBytesPerRequest) break;
+            count2++;
+            bytes += chunk.byteLength;
+          }
+          const group = buffer2.slice(0, count2);
+          buffer2 = buffer2.slice(count2);
+          bufferBytes -= bytes;
+          return {
+            group,
+            bytes
+          };
+        }, "takeGroup");
+        const sendGroup = /* @__PURE__ */ __name(async (group, bytes, groupT0) => {
           await ensureRunReady();
-          const chunksToFlush = buffer2.slice();
-          const batchStart = batchStartAt;
-          batchStartAt = void 0;
-          const dispatchAt = Date.now();
           const world = await worldPromise;
-          if (resolvedFlushIntervalMs === void 0) {
-            resolvedFlushIntervalMs = world.streamFlushIntervalMs ?? getStreamFlushIntervalMs();
+          const dispatchAt = Date.now();
+          if (typeof world.streams.writeMulti === "function" && group.length > 1) {
+            await world.streams.writeMulti(runId, name, group);
+          } else {
+            for (const chunk of group) {
+              await world.streams.write(runId, name, chunk);
+            }
           }
-          const rpcStartAt = Date.now();
-          try {
-            if (typeof world.streams.writeMulti === "function" && chunksToFlush.length > 1) {
-              await world.streams.writeMulti(runId, name, chunksToFlush);
-            } else {
-              for (const chunk of chunksToFlush) {
-                await world.streams.write(runId, name, chunk);
-              }
+          if (groupT0 !== void 0) {
+            recordStreamWriteFlush(groupT0, dispatchAt, runId, name, group.length, bytes, Date.now() - dispatchAt);
+          }
+        }, "sendGroup");
+        const dispatchLoop = /* @__PURE__ */ __name(async () => {
+          while (buffer2.length > 0) {
+            if (flushTimer) {
+              clearTimeout(flushTimer);
+              flushTimer = null;
             }
-          } catch (error48) {
-            if (batchStart !== void 0) {
-              batchStartAt = batchStartAt === void 0 ? batchStart : Math.min(batchStartAt, batchStart);
+            const groupT0 = bufferT0;
+            const groupTakenAt = Date.now();
+            const { group, bytes } = takeGroup();
+            inFlightChunks = group.length;
+            inFlightBytes = bytes;
+            bufferT0 = buffer2.length > 0 ? groupTakenAt : void 0;
+            try {
+              await sendGroup(group, bytes, groupT0);
+              inFlightChunks = 0;
+              inFlightBytes = 0;
+            } catch (error48) {
+              buffer2 = group.concat(buffer2);
+              bufferBytes += bytes;
+              inFlightChunks = 0;
+              inFlightBytes = 0;
+              bufferT0 = groupT0 !== void 0 && bufferT0 !== void 0 ? Math.min(groupT0, bufferT0) : groupT0 ?? bufferT0;
+              throw error48;
+            }
+            const relieved = capacityWaiters;
+            capacityWaiters = [];
+            for (const w of relieved) w.resolve();
+          }
+        }, "dispatchLoop");
+        const startDispatch = /* @__PURE__ */ __name(() => {
+          if (inFlight || sinkError !== void 0 || buffer2.length === 0) return;
+          inFlight = dispatchLoop().then(() => {
+            inFlight = null;
+            if (buffer2.length > 0) {
+              startDispatch();
+              return;
             }
-            throw error48;
+            const settled = drainWaiters;
+            drainWaiters = [];
+            for (const w of settled) w.resolve();
+          }, (error48) => {
+            inFlight = null;
+            sinkError ??= error48;
+            rejectWaiters(sinkError);
+          });
+        }, "startDispatch");
+        const scheduleGroupCommit = /* @__PURE__ */ __name(() => {
+          if (flushTimer || inFlight) return;
+          if (resolvedFlushIntervalMs === void 0) {
+            flushIntervalResolution ??= Promise.resolve(worldPromise).then((world) => {
+              resolvedFlushIntervalMs = world.streamFlushIntervalMs ?? STREAM_FLUSH_INTERVAL_MS;
+            }, () => {
+              resolvedFlushIntervalMs = STREAM_FLUSH_INTERVAL_MS;
+            }).then(() => {
+              if (buffer2.length > 0) scheduleGroupCommit();
+            });
+            return;
           }
-          if (batchStart !== void 0) {
-            recordStreamWriteFlush(batchStart, dispatchAt, runId, name, chunksToFlush.length, chunksToFlush.reduce((sum, c) => sum + c.byteLength, 0), Date.now() - rpcStartAt);
+          if (resolvedFlushIntervalMs <= 0) {
+            startDispatch();
+            return;
           }
-          buffer2 = [];
-        }, "flush");
-        let flushWaiters = [];
-        const scheduleFlush = /* @__PURE__ */ __name(() => {
-          if (flushTimer) return;
           flushTimer = setTimeout(() => {
             flushTimer = null;
-            const currentWaiters = flushWaiters;
-            flushWaiters = [];
-            flushPromise = flush().then(() => {
-              for (const w of currentWaiters) w.resolve();
-            }, (err) => {
-              for (const w of currentWaiters) w.reject(err);
-            });
-          }, resolvedFlushIntervalMs ?? getStreamFlushIntervalMs());
-        }, "scheduleFlush");
-        super({
-          async write(chunk) {
-            if (batchStartAt === void 0) batchStartAt = Date.now();
-            if (flushPromise) {
-              await flushPromise;
-              flushPromise = null;
-            }
-            buffer2.push(chunk);
-            scheduleFlush();
+            startDispatch();
+          }, resolvedFlushIntervalMs);
+        }, "scheduleGroupCommit");
+        const drain = /* @__PURE__ */ __name(async () => {
+          while (true) {
+            if (sinkError !== void 0) throw sinkError;
+            if (buffer2.length === 0 && !inFlight) return;
+            startDispatch();
             await new Promise((resolve, reject) => {
-              flushWaiters.push({
+              drainWaiters.push({
                 resolve,
                 reject
               });
             });
+          }
+        }, "drain");
+        super({
+          async write(chunk) {
+            if (sinkError !== void 0) throw sinkError;
+            if (bufferT0 === void 0) bufferT0 = Date.now();
+            buffer2.push(chunk);
+            bufferBytes += chunk.byteLength;
+            if (buffer2.length >= maxChunksPerRequest || bufferBytes >= maxBytesPerRequest) {
+              startDispatch();
+            } else {
+              scheduleGroupCommit();
+            }
+            while (sinkError === void 0 && (buffer2.length + inFlightChunks >= maxBufferedChunks || bufferBytes + inFlightBytes >= maxBufferedBytes)) {
+              startDispatch();
+              await new Promise((resolve, reject) => {
+                capacityWaiters.push({
+                  resolve,
+                  reject
+                });
+              });
+            }
+            if (sinkError !== void 0) throw sinkError;
           },
           async close() {
-            if (flushPromise) {
-              await flushPromise;
-              flushPromise = null;
-            }
-            await flush();
+            await drain();
             await ensureRunReady();
             const world = await worldPromise;
             const closeStart = Date.now();
             await world.streams.close(runId, name);
             recordStreamClose(closeStart, runId, name);
           },
-          abort(reason) {
+          async abort(reason) {
+            try {
+              await drain();
+            } catch {
+            }
             if (flushTimer) {
               clearTimeout(flushTimer);
               flushTimer = null;
             }
             buffer2 = [];
-            const waiters = flushWaiters;
-            flushWaiters = [];
-            const abortError = reason ?? new Error("Stream aborted");
-            for (const w of waiters) w.reject(abortError);
+            bufferBytes = 0;
+            sinkError ??= reason ?? new Error("Stream aborted");
+            rejectWaiters(sinkError);
           }
         });
-        Object.defineProperty(this, STREAM_WRITE_BATCH_SYMBOL, {
-          value: /* @__PURE__ */ __name(async (chunks) => {
-            if (chunks.length === 0) return;
-            if (batchStartAt === void 0) batchStartAt = Date.now();
-            for (const chunk of chunks) buffer2.push(chunk);
-            await flush();
-          }, "value"),
+        Object.defineProperty(this, STREAM_DRAIN_SYMBOL, {
+          value: drain,
           enumerable: false,
           writable: false
         });
@@ -27770,7 +28385,7 @@ __builtin_set_attributes.maxRetries = INTERNAL_ATTRIBUTES_MAX_ATTEMPTS - 1;
 init_dist2();
 init_dist3();
 init_dist4();
-init_encryption();
+init_encryption2();
 init_serialization2();
 init_util2();
 init_get_world_lazy();
@@ -27778,7 +28393,7 @@ init_get_world_lazy();
 // ../core/dist/runtime/runs.js
 init_dist2();
 init_dist4();
-init_encryption();
+init_encryption2();
 init_serialization2();
 init_helpers();
 
@@ -27856,6 +28471,7 @@ __name(isRetryableWorldError, "isRetryableWorldError");
 // ../core/dist/runtime/start.js
 init_encryption();
 init_logger();
+init_sealed_box();
 init_serialization2();
 init_context_storage();
 init_semantic_conventions();
@@ -27919,8 +28535,10 @@ async function start(workflow, argsOrOptions, options) {
           deploymentId = currentDeploymentId;
         }
       }
+      const runId = `wrun_${world.createRunId ? world.createRunId(opts) : ulid3()}`;
       let framedByteStreams;
       let targetSupportsCompression;
+      let probedRunPublicKey;
       if (deploymentId === currentDeploymentId) {
         framedByteStreams = true;
         targetSupportsCompression = true;
@@ -27928,17 +28546,18 @@ async function start(workflow, argsOrOptions, options) {
         framedByteStreams = false;
         targetSupportsCompression = false;
       } else {
-        const probe = await healthCheck(world, "workflow", {
+        const probe = await healthCheck(world, {
           deploymentId,
+          runId,
           timeout: CROSS_DEPLOYMENT_CAPABILITY_PROBE_TIMEOUT_MS,
           namespace: opts.namespace
         }).catch(() => void 0);
+        probedRunPublicKey = probe?.encryptionPublicKey;
         const capabilities = getRunCapabilities(probe?.workflowCoreVersion);
         framedByteStreams = capabilities.framedByteStreams;
         targetSupportsCompression = capabilities.supportedFormats.has(SerializationFormat.GZIP);
       }
       const ops = [];
-      const runId = `wrun_${world.createRunId ? world.createRunId(opts) : ulid3()}`;
       const traceCarrier = await serializeTraceCarrier();
       const specVersion = opts.specVersion ?? world.specVersion;
       const v1Compat = isLegacySpecVersion(specVersion);
@@ -27975,11 +28594,20 @@ async function start(workflow, argsOrOptions, options) {
       if (opts.replayedFromRunId !== void 0 && !workflowRunIdSchema.safeParse(opts.replayedFromRunId).success) {
         throw new WorkflowRuntimeError(`replayedFromRunId must be a run ID (wrun_<ulid>); received ${JSON.stringify(String(opts.replayedFromRunId).slice(0, 64))}.`);
       }
-      const rawKey = await world.getEncryptionKeyForRun?.(runId, {
-        ...opts,
-        deploymentId
-      });
-      const encryptionKey = rawKey ? await importKey(rawKey) : void 0;
+      const probedPublicKey = decodeRunPublicKey(probedRunPublicKey);
+      let encryptionKey;
+      let encryptionPublicKey;
+      if (probedPublicKey) {
+        encryptionKey = sealTo(probedPublicKey);
+        encryptionPublicKey = probedRunPublicKey;
+      } else {
+        const rawKey = await world.getEncryptionKeyForRun?.(runId, {
+          ...opts,
+          deploymentId
+        });
+        encryptionKey = rawKey ? await importKey(rawKey) : void 0;
+        encryptionPublicKey = rawKey ? bytesToBase64((await deriveRunKeyPair(rawKey)).publicKey) : void 0;
+      }
       const compression = targetSupportsCompression && specVersion >= SPEC_VERSION_SUPPORTS_COMPRESSION;
       const workflowArguments = await dehydrateWorkflowArguments(args, runId, encryptionKey, ops, globalThis, v1Compat, framedByteStreams, compression);
       const executionContext = {
@@ -28001,6 +28629,9 @@ async function start(workflow, argsOrOptions, options) {
             workflowName,
             input: workflowArguments,
             executionContext,
+            ...encryptionPublicKey ? {
+              encryptionPublicKey
+            } : {},
             ...attributeSeed
           }
         }, {
@@ -28016,6 +28647,9 @@ async function start(workflow, argsOrOptions, options) {
               workflowName,
               specVersion,
               executionContext,
+              ...encryptionPublicKey ? {
+                encryptionPublicKey
+              } : {},
               ...attributeSeed
             }
           } : {}
@@ -28082,7 +28716,7 @@ __name(start, "start");
     value: "start",
     configurable: true
   });
-})(start, "step//@workflow/core/runtime/start@5.0.0-beta.36//start");
+})(start, "step//@workflow/core/runtime/start@5.0.0-beta.37//start");
 
 // ../core/dist/runtime/runs.js
 async function wakeUpRun(world, runId, options) {
@@ -28226,7 +28860,7 @@ var Run = class _Run {
         const world = await this.#lazyWorldPromise;
         const run2 = await world.runs.get(this.runId);
         const rawKey = await world.getEncryptionKeyForRun?.(run2);
-        return rawKey ? await importKey(rawKey) : void 0;
+        return rawKey ? await deriveRunPayloadKeys(rawKey) : void 0;
       })();
     }
     return this.#encryptionKeyPromise;
@@ -28418,7 +29052,7 @@ var Run = class _Run {
     value: "wakeUp",
     configurable: true
   });
-})(Run.prototype["wakeUp"], "step//@workflow/core/runtime/run@5.0.0-beta.36//Run#wakeUp");
+})(Run.prototype["wakeUp"], "step//@workflow/core/runtime/run@5.0.0-beta.37//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);
@@ -28427,7 +29061,7 @@ var Run = class _Run {
     value: "cancel",
     configurable: true
   });
-})(Run.prototype["cancel"], "step//@workflow/core/runtime/run@5.0.0-beta.36//Run#cancel");
+})(Run.prototype["cancel"], "step//@workflow/core/runtime/run@5.0.0-beta.37//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);
@@ -28436,7 +29070,7 @@ var Run = class _Run {
     value: "getReadable",
     configurable: true
   });
-})(Run.prototype["getReadable"], "step//@workflow/core/runtime/run@5.0.0-beta.36//Run#getReadable");
+})(Run.prototype["getReadable"], "step//@workflow/core/runtime/run@5.0.0-beta.37//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);
@@ -28445,7 +29079,7 @@ var Run = class _Run {
     value: "exists",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "exists").get, "step//@workflow/core/runtime/run@5.0.0-beta.36//Run#exists");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "exists").get, "step//@workflow/core/runtime/run@5.0.0-beta.37//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);
@@ -28454,7 +29088,7 @@ var Run = class _Run {
     value: "status",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "status").get, "step//@workflow/core/runtime/run@5.0.0-beta.36//Run#status");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "status").get, "step//@workflow/core/runtime/run@5.0.0-beta.37//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);
@@ -28463,7 +29097,7 @@ var Run = class _Run {
     value: "returnValue",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "returnValue").get, "step//@workflow/core/runtime/run@5.0.0-beta.36//Run#returnValue");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "returnValue").get, "step//@workflow/core/runtime/run@5.0.0-beta.37//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);
@@ -28472,7 +29106,7 @@ var Run = class _Run {
     value: "workflowName",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "workflowName").get, "step//@workflow/core/runtime/run@5.0.0-beta.36//Run#workflowName");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "workflowName").get, "step//@workflow/core/runtime/run@5.0.0-beta.37//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);
@@ -28481,7 +29115,7 @@ var Run = class _Run {
     value: "createdAt",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "createdAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.36//Run#createdAt");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "createdAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.37//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);
@@ -28490,7 +29124,7 @@ var Run = class _Run {
     value: "startedAt",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "startedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.36//Run#startedAt");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "startedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.37//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);
@@ -28499,7 +29133,7 @@ var Run = class _Run {
     value: "completedAt",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "completedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.36//Run#completedAt");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "completedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.37//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);
@@ -28509,7 +29143,7 @@ var Run = class _Run {
     enumerable: false,
     configurable: false
   });
-})(Run, "class//@workflow/core/runtime/run@5.0.0-beta.36//Run");
+})(Run, "class//@workflow/core/runtime/run@5.0.0-beta.37//Run");
 
 // ../workflow/dist/stdlib.js
 async function fetch2(...args) {
@@ -28773,6 +29407,7 @@ init_context_storage();
 
 // ../core/dist/step/writable-stream.js
 init_flushable_stream();
+init_sealed_box();
 init_serialization2();
 init_symbols();
 init_util2();