@workflow/world-testing 5.0.0-beta.17 → 5.0.0-beta.19

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

@@ -16321,7 +16321,7 @@ function requiresNewerWorld(v) {
     return false;
   return v > SPEC_VERSION_CURRENT2;
 }
-var SPEC_VERSION_LEGACY2, SPEC_VERSION_SUPPORTS_EVENT_SOURCING2, SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT2, SPEC_VERSION_SUPPORTS_ATTRIBUTES2, SPEC_VERSION_CURRENT2;
+var SPEC_VERSION_LEGACY2, SPEC_VERSION_SUPPORTS_EVENT_SOURCING2, SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT2, SPEC_VERSION_SUPPORTS_ATTRIBUTES2, SPEC_VERSION_SUPPORTS_COMPRESSION2, SPEC_VERSION_CURRENT2;
 var init_spec_version2 = __esm({
   "../world/dist/spec-version.js"() {
     "use strict";
@@ -16329,7 +16329,8 @@ var init_spec_version2 = __esm({
     SPEC_VERSION_SUPPORTS_EVENT_SOURCING2 = 2;
     SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT2 = 3;
     SPEC_VERSION_SUPPORTS_ATTRIBUTES2 = 4;
-    SPEC_VERSION_CURRENT2 = SPEC_VERSION_SUPPORTS_ATTRIBUTES2;
+    SPEC_VERSION_SUPPORTS_COMPRESSION2 = 5;
+    SPEC_VERSION_CURRENT2 = SPEC_VERSION_SUPPORTS_COMPRESSION2;
     __name(isLegacySpecVersion2, "isLegacySpecVersion");
     __name(requiresNewerWorld, "requiresNewerWorld");
   }
@@ -16660,6 +16661,7 @@ __export(dist_exports, {
   SPEC_VERSION_LEGACY: () => SPEC_VERSION_LEGACY2,
   SPEC_VERSION_SUPPORTS_ATTRIBUTES: () => SPEC_VERSION_SUPPORTS_ATTRIBUTES2,
   SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT: () => SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT2,
+  SPEC_VERSION_SUPPORTS_COMPRESSION: () => SPEC_VERSION_SUPPORTS_COMPRESSION2,
   SPEC_VERSION_SUPPORTS_EVENT_SOURCING: () => SPEC_VERSION_SUPPORTS_EVENT_SOURCING2,
   SerializedDataSchema: () => SerializedDataSchema2,
   StepInvokePayloadSchema: () => StepInvokePayloadSchema2,
@@ -17077,7 +17079,7 @@ var init_log_format2 = __esm({
 function SemanticConvention2(...names) {
   return (value) => Object.fromEntries(names.map((name) => [name, value]));
 }
-var WorkflowName2, WorkflowOperation2, WorkflowRunId2, WorkflowRunStatus2, WorkflowStartedAt2, WorkflowEventsCount2, WorkflowArgumentsCount2, WorkflowResultType2, WorkflowTracePropagated2, WorkflowTraceMode2, WorkflowErrorName2, WorkflowErrorMessage2, WorkflowErrorCode2, WorkflowStepsCreated2, WorkflowHooksCreated2, WorkflowWaitsCreated2, StepName2, StepId2, StepAttempt2, StepStatus2, StepMaxRetries2, StepTracePropagated2, StepSkipped2, StepSkipReason2, StepArgumentsCount2, StepResultType2, StepErrorName2, StepErrorMessage2, StepFatalError2, StepRetryExhausted2, StepRetryTimeoutSeconds2, StepRetryWillRetry2, MessagingSystem2, MessagingDestinationName2, MessagingMessageId2, MessagingOperationType2, QueueOverheadMs2, DeploymentId2, HookToken2, HookId2, HookFound2, WebhookHandlersTriggered2, WorkflowSuspensionState2, WorkflowSuspensionHookCount2, WorkflowSuspensionStepCount2, WorkflowSuspensionWaitCount2, HttpRequestMethod2, UrlFull2, ServerAddress2, ServerPort2, HttpResponseStatusCode2, ErrorType2, WorldParseFormat2, WorkflowEventsPagesLoaded2, QueueDeserializeTimeMs2, QueueExecutionTimeMs2, QueueSerializeTimeMs2, PeerService2, RpcSystem2, RpcService2, RpcMethod2, ErrorRetryable2, ErrorCategory2;
+var WorkflowName2, WorkflowOperation2, WorkflowRunId2, WorkflowRunStatus2, WorkflowStartedAt2, WorkflowEventsCount2, WorkflowArgumentsCount2, WorkflowResultType2, WorkflowTracePropagated2, WorkflowTraceMode2, WorkflowErrorName2, WorkflowErrorMessage2, WorkflowErrorCode2, WorkflowStepsCreated2, WorkflowHooksCreated2, WorkflowWaitsCreated2, StepName2, StepId2, StepAttempt2, StepStatus2, StepMaxRetries2, StepTracePropagated2, StepSkipped2, StepSkipReason2, StepArgumentsCount2, StepResultType2, StepErrorName2, StepErrorMessage2, StepFatalError2, StepRetryExhausted2, StepRetryTimeoutSeconds2, StepRetryWillRetry2, MessagingSystem2, MessagingDestinationName2, MessagingMessageId2, MessagingOperationType2, QueueOverheadMs2, DeploymentId2, HookToken2, HookId2, HookFound2, WebhookHandlersTriggered2, WorkflowSuspensionState2, WorkflowSuspensionHookCount2, WorkflowSuspensionStepCount2, WorkflowSuspensionWaitCount2, HttpRequestMethod2, UrlFull2, ServerAddress2, ServerPort2, HttpResponseStatusCode2, ErrorType2, WorldParseFormat2, WorkflowEventsPagesLoaded2, QueueDeserializeTimeMs2, QueueExecutionTimeMs2, QueueSerializeTimeMs2, SerializationOperation2, SerializationCompressed2, SerializationCodec2, SerializationUncompressedBytes2, SerializationStoredBytes2, SerializationCompressionRatio2, PeerService2, RpcSystem2, RpcService2, RpcMethod2, ErrorRetryable2, ErrorCategory2;
 var init_semantic_conventions2 = __esm({
   "../core/dist/telemetry/semantic-conventions.js"() {
     "use strict";
@@ -17139,6 +17141,12 @@ var init_semantic_conventions2 = __esm({
     QueueDeserializeTimeMs2 = SemanticConvention2("workflow.queue.deserialize_time_ms");
     QueueExecutionTimeMs2 = SemanticConvention2("workflow.queue.execution_time_ms");
     QueueSerializeTimeMs2 = SemanticConvention2("workflow.queue.serialize_time_ms");
+    SerializationOperation2 = SemanticConvention2("workflow.serialization.operation");
+    SerializationCompressed2 = SemanticConvention2("workflow.serialization.compressed");
+    SerializationCodec2 = SemanticConvention2("workflow.serialization.codec");
+    SerializationUncompressedBytes2 = SemanticConvention2("workflow.serialization.uncompressed_bytes");
+    SerializationStoredBytes2 = SemanticConvention2("workflow.serialization.stored_bytes");
+    SerializationCompressionRatio2 = SemanticConvention2("workflow.serialization.compression_ratio");
     PeerService2 = SemanticConvention2("peer.service");
     RpcSystem2 = SemanticConvention2("rpc.system");
     RpcService2 = SemanticConvention2("rpc.service");
@@ -19177,7 +19185,7 @@ var version4;
 var init_version3 = __esm({
   "../core/dist/version.js"() {
     "use strict";
-    version4 = "5.0.0-beta.17";
+    version4 = "5.0.0-beta.19";
   }
 });
 
@@ -20911,7 +20919,11 @@ var init_types3 = __esm({
       /** devalue stringify/parse with TextEncoder/TextDecoder */
       DEVALUE_V1: "devl",
       /** Encrypted payload (inner payload has its own format prefix) */
-      ENCRYPTED: "encr"
+      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"
     };
   }
 });
@@ -21060,6 +21072,168 @@ var init_format2 = __esm({
   }
 });
 
+// ../core/dist/serialization/compression.js
+function isCompressionDisabledByEnv2() {
+  try {
+    return typeof process !== "undefined" && process.env?.WORKFLOW_DISABLE_COMPRESSION === "1";
+  } catch {
+    return false;
+  }
+}
+function codecOverrideFromEnv2() {
+  try {
+    const v = process.env?.WORKFLOW_COMPRESSION_CODEC;
+    return v === "gzip" || v === "zstd" ? v : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function getNodeZlib2() {
+  try {
+    return globalThis.process?.getBuiltinModule?.("node:zlib");
+  } catch {
+    return void 0;
+  }
+}
+function isZstdAvailable2() {
+  const z3 = getNodeZlib2();
+  return typeof z3?.zstdCompressSync === "function" && typeof z3?.zstdDecompressSync === "function";
+}
+function isGzipAvailable2() {
+  return typeof CompressionStream === "function" && typeof DecompressionStream === "function";
+}
+async function pipeThroughTransform2(data, transform3) {
+  const writer = transform3.writable.getWriter();
+  const writePromise = writer.write(data).then(() => writer.close());
+  writePromise.catch(() => {
+  });
+  const chunks = [];
+  let total = 0;
+  const reader = transform3.readable.getReader();
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    chunks.push(value);
+    total += value.length;
+  }
+  await writePromise;
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return out;
+}
+async function gzipBytes2(data) {
+  return pipeThroughTransform2(data, new CompressionStream("gzip"));
+}
+async function gunzipBytes2(data) {
+  return pipeThroughTransform2(data, new DecompressionStream("gzip"));
+}
+function zstdBytes2(data) {
+  const z3 = getNodeZlib2();
+  const level = z3?.constants?.ZSTD_c_compressionLevel;
+  const opts = level !== void 0 ? { params: { [level]: ZSTD_LEVEL2 } } : void 0;
+  return new Uint8Array(z3.zstdCompressSync(data, opts));
+}
+function unzstdBytes2(data) {
+  const z3 = getNodeZlib2();
+  if (!z3?.zstdDecompressSync) {
+    throw new Error("Compressed (zstd) workflow data encountered but node:zlib zstd support is not available in this runtime (requires Node.js 22.15+). In the browser, register a zstd decoder via registerZstdDecoder (serialization-format.ts).");
+  }
+  return new Uint8Array(z3.zstdDecompressSync(data));
+}
+function recordStats2(stats, codec3, uncompressedBytes, storedBytes) {
+  if (!stats)
+    return;
+  stats.recorded = true;
+  stats.compressed = codec3 !== "none";
+  stats.codec = codec3;
+  stats.uncompressedBytes = uncompressedBytes;
+  stats.storedBytes = storedBytes;
+}
+function selectWriteCodec2() {
+  const override = codecOverrideFromEnv2();
+  if (override === "gzip")
+    return isGzipAvailable2() ? "gzip" : "none";
+  if (isZstdAvailable2())
+    return "zstd";
+  if (isGzipAvailable2())
+    return "gzip";
+  return "none";
+}
+async function compress2(data, enabled, stats) {
+  if (!(data instanceof Uint8Array))
+    return data;
+  if (!enabled || data.length < COMPRESSION_MIN_BYTES2 || isCompressionDisabledByEnv2()) {
+    recordStats2(stats, "none", data.length, data.length);
+    return data;
+  }
+  const codec3 = selectWriteCodec2();
+  if (codec3 === "none") {
+    recordStats2(stats, "none", data.length, data.length);
+    return data;
+  }
+  const compressed = codec3 === "zstd" ? zstdBytes2(data) : await gzipBytes2(data);
+  const format = codec3 === "zstd" ? SerializationFormat2.ZSTD : SerializationFormat2.GZIP;
+  const wrappedLength = 4 + compressed.length;
+  if (wrappedLength >= data.length * (1 - COMPRESSION_MIN_SAVINGS_RATIO2)) {
+    recordStats2(stats, "none", data.length, data.length);
+    return data;
+  }
+  recordStats2(stats, codec3, data.length, wrappedLength);
+  return encodeWithFormatPrefix2(format, compressed);
+}
+async function decompress2(data, stats) {
+  if (!(data instanceof Uint8Array))
+    return data;
+  const prefix = peekFormatPrefix2(data);
+  if (prefix === SerializationFormat2.ZSTD) {
+    const { payload } = decodeFormatPrefix2(data);
+    const inflated = unzstdBytes2(payload);
+    recordStats2(stats, "zstd", inflated.length, data.length);
+    return inflated;
+  }
+  if (prefix === SerializationFormat2.GZIP) {
+    if (!isGzipAvailable2()) {
+      throw new Error("Compressed (gzip) workflow data encountered but DecompressionStream is not available in this runtime. Node.js 18+, browsers, and edge runtimes all support it.");
+    }
+    const { payload } = decodeFormatPrefix2(data);
+    const inflated = await gunzipBytes2(payload);
+    recordStats2(stats, "gzip", inflated.length, data.length);
+    return inflated;
+  }
+  recordStats2(stats, "none", data.length, data.length);
+  return data;
+}
+var COMPRESSION_MIN_BYTES2, COMPRESSION_MIN_SAVINGS_RATIO2, ZSTD_LEVEL2;
+var init_compression2 = __esm({
+  "../core/dist/serialization/compression.js"() {
+    "use strict";
+    init_format2();
+    init_types3();
+    COMPRESSION_MIN_BYTES2 = 1024;
+    COMPRESSION_MIN_SAVINGS_RATIO2 = 0.05;
+    ZSTD_LEVEL2 = 3;
+    __name(isCompressionDisabledByEnv2, "isCompressionDisabledByEnv");
+    __name(codecOverrideFromEnv2, "codecOverrideFromEnv");
+    __name(getNodeZlib2, "getNodeZlib");
+    __name(isZstdAvailable2, "isZstdAvailable");
+    __name(isGzipAvailable2, "isGzipAvailable");
+    __name(pipeThroughTransform2, "pipeThroughTransform");
+    __name(gzipBytes2, "gzipBytes");
+    __name(gunzipBytes2, "gunzipBytes");
+    __name(zstdBytes2, "zstdBytes");
+    __name(unzstdBytes2, "unzstdBytes");
+    __name(recordStats2, "recordStats");
+    __name(selectWriteCodec2, "selectWriteCodec");
+    __name(compress2, "compress");
+    __name(decompress2, "decompress");
+  }
+});
+
 // ../core/dist/serialization/encryption.js
 async function resolveEncryptionKey2(key) {
   return typeof key === "function" ? key() : key;
@@ -21142,7 +21316,7 @@ var init_errors6 = __esm({
 
 // ../core/dist/serialization/client.js
 async function deserialize3(data, encryptionKey, options) {
-  const decrypted = await decrypt4(data, encryptionKey);
+  const decrypted = await decompress2(await decrypt4(data, encryptionKey), options?.compressionStats);
   if (!(decrypted instanceof Uint8Array)) {
     if (devalueCodec2.deserializeLegacy) {
       return devalueCodec2.deserializeLegacy(decrypted, "client", options);
@@ -21160,6 +21334,7 @@ var init_client2 = __esm({
     "use strict";
     init_dist6();
     init_codec_devalue2();
+    init_compression2();
     init_encryption4();
     init_errors6();
     init_format2();
@@ -21173,7 +21348,8 @@ async function serialize3(value, encryptionKey, options) {
   try {
     const payload = devalueCodec2.serialize(value, "step", options);
     const prefixed = encodeWithFormatPrefix2(SerializationFormat2.DEVALUE_V1, payload);
-    return encrypt4(prefixed, encryptionKey);
+    const compressed = await compress2(prefixed, options?.compression === true, options?.compressionStats);
+    return encrypt4(compressed, encryptionKey);
   } catch (error95) {
     rethrowIfRuntimeError2(error95);
     const { message, hint: hint3 } = formatSerializationError2("step value", error95);
@@ -21181,7 +21357,7 @@ async function serialize3(value, encryptionKey, options) {
   }
 }
 async function deserialize4(data, encryptionKey, options) {
-  const decrypted = await decrypt4(data, encryptionKey);
+  const decrypted = await decompress2(await decrypt4(data, encryptionKey), options?.compressionStats);
   if (!(decrypted instanceof Uint8Array)) {
     if (devalueCodec2.deserializeLegacy) {
       return devalueCodec2.deserializeLegacy(decrypted, "step", options);
@@ -21199,6 +21375,7 @@ var init_step2 = __esm({
     "use strict";
     init_dist6();
     init_codec_devalue2();
+    init_compression2();
     init_encryption4();
     init_errors6();
     init_format2();
@@ -23591,7 +23768,15 @@ var init_capabilities2 = __esm({
     import_semver3 = __toESM(require_semver5(), 1);
     init_serialization4();
     FORMAT_VERSION_TABLE2 = [
-      { format: SerializationFormat2.ENCRYPTED, minVersion: "4.2.0-beta.64" }
+      { format: SerializationFormat2.ENCRYPTED, minVersion: "4.2.0-beta.64" },
+      // TODO(release): verify this matches the actual version that ships payload
+      // compression. If a "Version Packages (beta)" PR merges before this change,
+      // bump to the next beta. A too-low cutoff makes new producers write
+      // compressed payloads to consumers that cannot decompress them; too-high
+      // merely delays the optimization (safe). gzip and zstd ship together, so
+      // they share a min version — a run that can read one can read both.
+      { format: SerializationFormat2.GZIP, minVersion: "5.0.0-beta.18" },
+      { format: SerializationFormat2.ZSTD, minVersion: "5.0.0-beta.18" }
       // Future entries:
       // { format: SerializationFormat.CBOR, minVersion: '5.x.y' },
       // { format: SerializationFormat.ENCRYPTED_V2, minVersion: '5.x.y' },
@@ -24797,9 +24982,10 @@ async function resumeHook2(tokenOrHook, payload, encryptionKeyOverride) {
         if (!capabilities.supportedFormats.has(SerializationFormat2.ENCRYPTED)) {
           encryptionKey = void 0;
         }
+        const compression = (workflowRun.specVersion ?? 0) >= SPEC_VERSION_SUPPORTS_COMPRESSION2 && capabilities.supportedFormats.has(SerializationFormat2.GZIP);
         const ops = [];
         const v1Compat = isLegacySpecVersion2(hook.specVersion);
-        const dehydratedPayload = await dehydrateStepReturnValue2(payload, hook.runId, encryptionKey, ops, globalThis, v1Compat, capabilities.framedByteStreams);
+        const dehydratedPayload = await dehydrateStepReturnValue2(payload, hook.runId, encryptionKey, ops, globalThis, v1Compat, capabilities.framedByteStreams, compression);
         safeWaitUntil2(Promise.all(ops), (err) => {
           if (err === void 0)
             return;
@@ -24921,6 +25107,26 @@ function unwrapSerializationCause2(error95) {
   }
   return error95;
 }
+async function recordCompression2(stats, operation) {
+  if (!stats.recorded)
+    return;
+  try {
+    const span = await getActiveSpan3();
+    if (!span)
+      return;
+    const uncompressedBytes = stats.uncompressedBytes ?? 0;
+    const storedBytes = stats.storedBytes ?? 0;
+    span.setAttributes({
+      ...SerializationOperation2(operation),
+      ...SerializationCompressed2(stats.compressed ?? false),
+      ...SerializationCodec2(stats.codec ?? "none"),
+      ...SerializationUncompressedBytes2(uncompressedBytes),
+      ...SerializationStoredBytes2(storedBytes),
+      ...stats.compressed && uncompressedBytes > 0 ? SerializationCompressionRatio2(1 - storedBytes / uncompressedBytes) : {}
+    });
+  } catch {
+  }
+}
 function getSerializeStream2(reducers, cryptoKey) {
   const encoder3 = new TextEncoder();
   const keyState = { resolved: false, key: void 0 };
@@ -25970,7 +26176,10 @@ async function maybeDecrypt2(data, key) {
   return decrypt4(data, key);
 }
 async function hydrateWorkflowArguments(value, _runId, key, global2 = globalThis, extraRevivers = {}) {
-  return deserialize5(await maybeDecrypt2(value, key), {
+  const compressionStats = {};
+  const inflated = await decompress2(await maybeDecrypt2(value, key), compressionStats);
+  await recordCompression2(compressionStats, "deserialize");
+  return deserialize5(inflated, {
     global: global2,
     extraRevivers: {
       ...getStreamAndRequestRevivers2(getWorkflowRevivers(global2)),
@@ -25978,16 +26187,21 @@ async function hydrateWorkflowArguments(value, _runId, key, global2 = globalThis
     }
   });
 }
-async function dehydrateWorkflowReturnValue(value, _runId, key, global2 = globalThis, v1Compat = false) {
+async function dehydrateWorkflowReturnValue(value, _runId, key, global2 = globalThis, v1Compat = false, compression = false) {
   if (v1Compat) {
     const str = stringify2(value, getWorkflowReducers2(global2));
     return revive2(str);
   }
   try {
-    return await serialize3(value, key, {
+    const compressionStats = {};
+    const result = await serialize3(value, key, {
       global: global2,
-      extraReducers: getStreamAndRequestReducers2(getWorkflowReducers2(global2))
+      extraReducers: getStreamAndRequestReducers2(getWorkflowReducers2(global2)),
+      compression,
+      compressionStats
     });
+    await recordCompression2(compressionStats, "serialize");
+    return result;
   } catch (error95) {
     const cause = unwrapSerializationCause2(error95);
     const { message, hint: hint3 } = formatSerializationError2("workflow return value", cause);
@@ -25995,24 +26209,33 @@ async function dehydrateWorkflowReturnValue(value, _runId, key, global2 = global
   }
 }
 async function hydrateWorkflowReturnValue2(value, runId, key, ops = [], global2 = globalThis, extraRevivers = {}) {
-  return deserialize3(value, key, {
+  const compressionStats = {};
+  const result = await deserialize3(value, key, {
     global: global2,
     extraRevivers: {
       ...getStreamAndRequestRevivers2(getExternalRevivers2(global2, ops, runId, key)),
       ...extraRevivers
-    }
+    },
+    compressionStats
   });
+  await recordCompression2(compressionStats, "deserialize");
+  return result;
 }
-async function dehydrateStepArguments2(value, _runId, key, global2 = globalThis, v1Compat = false) {
+async function dehydrateStepArguments2(value, _runId, key, global2 = globalThis, v1Compat = false, compression = false) {
   if (v1Compat) {
     const str = stringify2(value, getWorkflowReducers2(global2));
     return revive2(str);
   }
   try {
-    return await serialize3(value, key, {
+    const compressionStats = {};
+    const result = await serialize3(value, key, {
       global: global2,
-      extraReducers: getStreamAndRequestReducers2(getWorkflowReducers2(global2))
+      extraReducers: getStreamAndRequestReducers2(getWorkflowReducers2(global2)),
+      compression,
+      compressionStats
     });
+    await recordCompression2(compressionStats, "serialize");
+    return result;
   } catch (error95) {
     const cause = unwrapSerializationCause2(error95);
     const { message, hint: hint3 } = formatSerializationError2("step arguments", cause);
@@ -26020,36 +26243,49 @@ async function dehydrateStepArguments2(value, _runId, key, global2 = globalThis,
   }
 }
 async function hydrateStepArguments2(value, runId, key, ops = [], global2 = globalThis, extraRevivers = {}, deploymentId) {
-  return deserialize4(value, key, {
+  const compressionStats = {};
+  const result = await deserialize4(value, key, {
     global: global2,
     extraRevivers: {
       ...getStreamAndRequestRevivers2(getStepRevivers2(global2, ops, runId, key, deploymentId)),
       ...extraRevivers
-    }
+    },
+    compressionStats
   });
+  await recordCompression2(compressionStats, "deserialize");
+  return result;
 }
-async function dehydrateStepReturnValue2(value, runId, key, ops = [], global2 = globalThis, v1Compat = false, framedByteStreams = false) {
+async function dehydrateStepReturnValue2(value, runId, key, ops = [], global2 = globalThis, v1Compat = false, framedByteStreams = false, compression = false) {
   if (v1Compat) {
     const str = stringify2(value, getStepReducers2(global2, ops, runId, key, framedByteStreams));
     return revive2(str);
   }
   try {
-    return await serialize3(value, key, {
+    const compressionStats = {};
+    const result = await serialize3(value, key, {
       global: global2,
-      extraReducers: getStreamAndRequestReducers2(getStepReducers2(global2, ops, runId, key, framedByteStreams))
+      extraReducers: getStreamAndRequestReducers2(getStepReducers2(global2, ops, runId, key, framedByteStreams)),
+      compression,
+      compressionStats
     });
+    await recordCompression2(compressionStats, "serialize");
+    return result;
   } catch (error95) {
     const cause = unwrapSerializationCause2(error95);
     const { message, hint: hint3 } = formatSerializationError2("step return value", cause);
     throw new SerializationError2(message, { hint: hint3, cause });
   }
 }
-async function dehydrateStepError(value, runId, key, ops = [], global2 = globalThis) {
+async function dehydrateStepError(value, runId, key, ops = [], global2 = globalThis, compression = false) {
   try {
     const str = stringify2(value, getStepReducers2(global2, ops, runId, key));
     const payload = new TextEncoder().encode(str);
     const serialized = encodeWithFormatPrefix2(SerializationFormat2.DEVALUE_V1, payload);
-    return await maybeEncrypt(serialized, key);
+    const compressionStats = {};
+    const compressed = await compress2(serialized, compression, compressionStats);
+    const encrypted = await maybeEncrypt(compressed, key);
+    await recordCompression2(compressionStats, "serialize");
+    return encrypted;
   } catch (error95) {
     const cause = unwrapSerializationCause2(error95);
     const { message, hint: hint3 } = formatSerializationError2("step error", cause);
@@ -26057,7 +26293,9 @@ async function dehydrateStepError(value, runId, key, ops = [], global2 = globalT
   }
 }
 async function hydrateStepError(value, _runId, key, global2 = globalThis, extraRevivers = {}) {
-  const decrypted = await maybeDecrypt2(value, key);
+  const compressionStats = {};
+  const decrypted = await decompress2(await maybeDecrypt2(value, key), compressionStats);
+  await recordCompression2(compressionStats, "deserialize");
   if (!(decrypted instanceof Uint8Array)) {
     return unflatten2(decrypted, {
       ...getWorkflowRevivers(global2),
@@ -26074,12 +26312,16 @@ async function hydrateStepError(value, _runId, key, global2 = globalThis, extraR
   }
   throw new Error(`Unsupported serialization format: ${format}`);
 }
-async function dehydrateRunError(value, _runId, key, global2 = globalThis) {
+async function dehydrateRunError(value, _runId, key, global2 = globalThis, compression = false) {
   try {
     const str = stringify2(value, getWorkflowReducers2(global2));
     const payload = new TextEncoder().encode(str);
     const serialized = encodeWithFormatPrefix2(SerializationFormat2.DEVALUE_V1, payload);
-    return await maybeEncrypt(serialized, key);
+    const compressionStats = {};
+    const compressed = await compress2(serialized, compression, compressionStats);
+    const encrypted = await maybeEncrypt(compressed, key);
+    await recordCompression2(compressionStats, "serialize");
+    return encrypted;
   } catch (error95) {
     const cause = unwrapSerializationCause2(error95);
     const { message, hint: hint3 } = formatSerializationError2("run error", cause);
@@ -26087,7 +26329,9 @@ async function dehydrateRunError(value, _runId, key, global2 = globalThis) {
   }
 }
 async function hydrateRunError2(value, runId, key, ops = [], global2 = globalThis, extraRevivers = {}) {
-  const decrypted = await maybeDecrypt2(value, key);
+  const compressionStats = {};
+  const decrypted = await decompress2(await maybeDecrypt2(value, key), compressionStats);
+  await recordCompression2(compressionStats, "deserialize");
   if (!(decrypted instanceof Uint8Array)) {
     return unflatten2(decrypted, {
       ...getExternalRevivers2(global2, ops, runId, key),
@@ -26105,7 +26349,10 @@ async function hydrateRunError2(value, runId, key, ops = [], global2 = globalThi
   throw new Error(`Unsupported serialization format: ${format}`);
 }
 async function hydrateStepReturnValue(value, _runId, key, global2 = globalThis, extraRevivers = {}) {
-  return deserialize5(await maybeDecrypt2(value, key), {
+  const compressionStats = {};
+  const inflated = await decompress2(await maybeDecrypt2(value, key), compressionStats);
+  await recordCompression2(compressionStats, "deserialize");
+  return deserialize5(inflated, {
     global: global2,
     extraRevivers: {
       ...getStreamAndRequestRevivers2(getWorkflowRevivers(global2)),
@@ -26143,6 +26390,7 @@ var init_serialization4 = __esm({
     init_private2();
     init_get_world_lazy2();
     init_client2();
+    init_compression2();
     init_encryption4();
     init_errors6();
     init_format2();
@@ -26154,12 +26402,15 @@ var init_serialization4 = __esm({
     init_workflow2();
     init_context_storage2();
     init_symbols2();
+    init_semantic_conventions2();
+    init_telemetry2();
     init_util4();
     init_abort_controller2();
     defaultUlid2 = monotonicFactory2();
     __name(getStreamType2, "getStreamType");
     FRAME_HEADER_SIZE2 = 4;
     __name(unwrapSerializationCause2, "unwrapSerializationCause");
+    __name(recordCompression2, "recordCompression");
     __name(getSerializeStream2, "getSerializeStream");
     __name(getDeserializeStream2, "getDeserializeStream");
     MAX_FRAME_SIZE2 = 1e8;
@@ -71951,6 +72202,7 @@ var SPEC_VERSION_LEGACY;
 var SPEC_VERSION_SUPPORTS_EVENT_SOURCING;
 var SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT;
 var SPEC_VERSION_SUPPORTS_ATTRIBUTES;
+var SPEC_VERSION_SUPPORTS_COMPRESSION;
 var SPEC_VERSION_CURRENT;
 var init_spec_version = __esm2({
   "../world/dist/spec-version.js"() {
@@ -71959,7 +72211,8 @@ var init_spec_version = __esm2({
     SPEC_VERSION_SUPPORTS_EVENT_SOURCING = 2;
     SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT = 3;
     SPEC_VERSION_SUPPORTS_ATTRIBUTES = 4;
-    SPEC_VERSION_CURRENT = SPEC_VERSION_SUPPORTS_ATTRIBUTES;
+    SPEC_VERSION_SUPPORTS_COMPRESSION = 5;
+    SPEC_VERSION_CURRENT = SPEC_VERSION_SUPPORTS_COMPRESSION;
     __name2(isLegacySpecVersion, "isLegacySpecVersion");
   }
 });
@@ -73766,7 +74019,11 @@ var init_types = __esm2({
       /** devalue stringify/parse with TextEncoder/TextDecoder */
       DEVALUE_V1: "devl",
       /** Encrypted payload (inner payload has its own format prefix) */
-      ENCRYPTED: "encr"
+      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"
     };
   }
 });
@@ -73928,6 +74185,179 @@ var init_format = __esm2({
     __name2(decodeFormatPrefix, "decodeFormatPrefix");
   }
 });
+function isCompressionDisabledByEnv() {
+  try {
+    return typeof process !== "undefined" && process.env?.WORKFLOW_DISABLE_COMPRESSION === "1";
+  } catch {
+    return false;
+  }
+}
+__name(isCompressionDisabledByEnv, "isCompressionDisabledByEnv");
+function codecOverrideFromEnv() {
+  try {
+    const v = process.env?.WORKFLOW_COMPRESSION_CODEC;
+    return v === "gzip" || v === "zstd" ? v : void 0;
+  } catch {
+    return void 0;
+  }
+}
+__name(codecOverrideFromEnv, "codecOverrideFromEnv");
+function getNodeZlib() {
+  try {
+    return globalThis.process?.getBuiltinModule?.("node:zlib");
+  } catch {
+    return void 0;
+  }
+}
+__name(getNodeZlib, "getNodeZlib");
+function isZstdAvailable() {
+  const z22 = getNodeZlib();
+  return typeof z22?.zstdCompressSync === "function" && typeof z22?.zstdDecompressSync === "function";
+}
+__name(isZstdAvailable, "isZstdAvailable");
+function isGzipAvailable() {
+  return typeof CompressionStream === "function" && typeof DecompressionStream === "function";
+}
+__name(isGzipAvailable, "isGzipAvailable");
+async function pipeThroughTransform(data, transform22) {
+  const writer = transform22.writable.getWriter();
+  const writePromise = writer.write(data).then(() => writer.close());
+  writePromise.catch(() => {
+  });
+  const chunks = [];
+  let total = 0;
+  const reader = transform22.readable.getReader();
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    chunks.push(value);
+    total += value.length;
+  }
+  await writePromise;
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return out;
+}
+__name(pipeThroughTransform, "pipeThroughTransform");
+async function gzipBytes(data) {
+  return pipeThroughTransform(data, new CompressionStream("gzip"));
+}
+__name(gzipBytes, "gzipBytes");
+async function gunzipBytes(data) {
+  return pipeThroughTransform(data, new DecompressionStream("gzip"));
+}
+__name(gunzipBytes, "gunzipBytes");
+function zstdBytes(data) {
+  const z22 = getNodeZlib();
+  const level = z22?.constants?.ZSTD_c_compressionLevel;
+  const opts = level !== void 0 ? {
+    params: {
+      [level]: ZSTD_LEVEL
+    }
+  } : void 0;
+  return new Uint8Array(z22.zstdCompressSync(data, opts));
+}
+__name(zstdBytes, "zstdBytes");
+function unzstdBytes(data) {
+  const z22 = getNodeZlib();
+  if (!z22?.zstdDecompressSync) {
+    throw new Error("Compressed (zstd) workflow data encountered but node:zlib zstd support is not available in this runtime (requires Node.js 22.15+). In the browser, register a zstd decoder via registerZstdDecoder (serialization-format.ts).");
+  }
+  return new Uint8Array(z22.zstdDecompressSync(data));
+}
+__name(unzstdBytes, "unzstdBytes");
+function recordStats(stats, codec22, uncompressedBytes, storedBytes) {
+  if (!stats) return;
+  stats.recorded = true;
+  stats.compressed = codec22 !== "none";
+  stats.codec = codec22;
+  stats.uncompressedBytes = uncompressedBytes;
+  stats.storedBytes = storedBytes;
+}
+__name(recordStats, "recordStats");
+function selectWriteCodec() {
+  const override = codecOverrideFromEnv();
+  if (override === "gzip") return isGzipAvailable() ? "gzip" : "none";
+  if (isZstdAvailable()) return "zstd";
+  if (isGzipAvailable()) return "gzip";
+  return "none";
+}
+__name(selectWriteCodec, "selectWriteCodec");
+async function compress(data, enabled, stats) {
+  if (!(data instanceof Uint8Array)) return data;
+  if (!enabled || data.length < COMPRESSION_MIN_BYTES || isCompressionDisabledByEnv()) {
+    recordStats(stats, "none", data.length, data.length);
+    return data;
+  }
+  const codec22 = selectWriteCodec();
+  if (codec22 === "none") {
+    recordStats(stats, "none", data.length, data.length);
+    return data;
+  }
+  const compressed = codec22 === "zstd" ? zstdBytes(data) : await gzipBytes(data);
+  const format = codec22 === "zstd" ? SerializationFormat.ZSTD : SerializationFormat.GZIP;
+  const wrappedLength = 4 + compressed.length;
+  if (wrappedLength >= data.length * (1 - COMPRESSION_MIN_SAVINGS_RATIO)) {
+    recordStats(stats, "none", data.length, data.length);
+    return data;
+  }
+  recordStats(stats, codec22, data.length, wrappedLength);
+  return encodeWithFormatPrefix(format, compressed);
+}
+__name(compress, "compress");
+async function decompress(data, stats) {
+  if (!(data instanceof Uint8Array)) return data;
+  const prefix = peekFormatPrefix(data);
+  if (prefix === SerializationFormat.ZSTD) {
+    const { payload } = decodeFormatPrefix(data);
+    const inflated = unzstdBytes(payload);
+    recordStats(stats, "zstd", inflated.length, data.length);
+    return inflated;
+  }
+  if (prefix === SerializationFormat.GZIP) {
+    if (!isGzipAvailable()) {
+      throw new Error("Compressed (gzip) workflow data encountered but DecompressionStream is not available in this runtime. Node.js 18+, browsers, and edge runtimes all support it.");
+    }
+    const { payload } = decodeFormatPrefix(data);
+    const inflated = await gunzipBytes(payload);
+    recordStats(stats, "gzip", inflated.length, data.length);
+    return inflated;
+  }
+  recordStats(stats, "none", data.length, data.length);
+  return data;
+}
+__name(decompress, "decompress");
+var COMPRESSION_MIN_BYTES;
+var COMPRESSION_MIN_SAVINGS_RATIO;
+var ZSTD_LEVEL;
+var init_compression = __esm2({
+  "../core/dist/serialization/compression.js"() {
+    "use strict";
+    init_format();
+    init_types();
+    COMPRESSION_MIN_BYTES = 1024;
+    COMPRESSION_MIN_SAVINGS_RATIO = 0.05;
+    ZSTD_LEVEL = 3;
+    __name2(isCompressionDisabledByEnv, "isCompressionDisabledByEnv");
+    __name2(codecOverrideFromEnv, "codecOverrideFromEnv");
+    __name2(getNodeZlib, "getNodeZlib");
+    __name2(isZstdAvailable, "isZstdAvailable");
+    __name2(isGzipAvailable, "isGzipAvailable");
+    __name2(pipeThroughTransform, "pipeThroughTransform");
+    __name2(gzipBytes, "gzipBytes");
+    __name2(gunzipBytes, "gunzipBytes");
+    __name2(zstdBytes, "zstdBytes");
+    __name2(unzstdBytes, "unzstdBytes");
+    __name2(recordStats, "recordStats");
+    __name2(selectWriteCodec, "selectWriteCodec");
+    __name2(compress, "compress");
+    __name2(decompress, "decompress");
+  }
+});
 async function resolveEncryptionKey(key) {
   return typeof key === "function" ? key() : key;
 }
@@ -74401,6 +74831,12 @@ var WorkflowEventsPagesLoaded;
 var QueueDeserializeTimeMs;
 var QueueExecutionTimeMs;
 var QueueSerializeTimeMs;
+var SerializationOperation;
+var SerializationCompressed;
+var SerializationCodec;
+var SerializationUncompressedBytes;
+var SerializationStoredBytes;
+var SerializationCompressionRatio;
 var PeerService;
 var RpcSystem;
 var RpcService;
@@ -74468,6 +74904,12 @@ var init_semantic_conventions = __esm2({
     QueueDeserializeTimeMs = SemanticConvention("workflow.queue.deserialize_time_ms");
     QueueExecutionTimeMs = SemanticConvention("workflow.queue.execution_time_ms");
     QueueSerializeTimeMs = SemanticConvention("workflow.queue.serialize_time_ms");
+    SerializationOperation = SemanticConvention("workflow.serialization.operation");
+    SerializationCompressed = SemanticConvention("workflow.serialization.compressed");
+    SerializationCodec = SemanticConvention("workflow.serialization.codec");
+    SerializationUncompressedBytes = SemanticConvention("workflow.serialization.uncompressed_bytes");
+    SerializationStoredBytes = SemanticConvention("workflow.serialization.stored_bytes");
+    SerializationCompressionRatio = SemanticConvention("workflow.serialization.compression_ratio");
     PeerService = SemanticConvention("peer.service");
     RpcSystem = SemanticConvention("rpc.system");
     RpcService = SemanticConvention("rpc.service");
@@ -76731,7 +77173,8 @@ async function serialize(value, encryptionKey, options) {
   try {
     const payload = devalueCodec.serialize(value, "client", options);
     const prefixed = encodeWithFormatPrefix(SerializationFormat.DEVALUE_V1, payload);
-    return encrypt2(prefixed, encryptionKey);
+    const compressed = await compress(prefixed, options?.compression === true, options?.compressionStats);
+    return encrypt2(compressed, encryptionKey);
   } catch (error482) {
     rethrowIfRuntimeError(error482);
     const { message, hint: hint22 } = formatSerializationError("client value", error482);
@@ -76743,7 +77186,7 @@ async function serialize(value, encryptionKey, options) {
 }
 __name(serialize, "serialize");
 async function deserialize(data, encryptionKey, options) {
-  const decrypted = await decrypt2(data, encryptionKey);
+  const decrypted = await decompress(await decrypt2(data, encryptionKey), options?.compressionStats);
   if (!(decrypted instanceof Uint8Array)) {
     if (devalueCodec.deserializeLegacy) {
       return devalueCodec.deserializeLegacy(decrypted, "client", options);
@@ -76762,6 +77205,7 @@ var init_client = __esm2({
     "use strict";
     init_dist2();
     init_codec_devalue();
+    init_compression();
     init_encryption2();
     init_errors3();
     init_format();
@@ -76774,7 +77218,8 @@ async function serialize2(value, encryptionKey, options) {
   try {
     const payload = devalueCodec.serialize(value, "step", options);
     const prefixed = encodeWithFormatPrefix(SerializationFormat.DEVALUE_V1, payload);
-    return encrypt2(prefixed, encryptionKey);
+    const compressed = await compress(prefixed, options?.compression === true, options?.compressionStats);
+    return encrypt2(compressed, encryptionKey);
   } catch (error482) {
     rethrowIfRuntimeError(error482);
     const { message, hint: hint22 } = formatSerializationError("step value", error482);
@@ -76786,7 +77231,7 @@ async function serialize2(value, encryptionKey, options) {
 }
 __name(serialize2, "serialize2");
 async function deserialize2(data, encryptionKey, options) {
-  const decrypted = await decrypt2(data, encryptionKey);
+  const decrypted = await decompress(await decrypt2(data, encryptionKey), options?.compressionStats);
   if (!(decrypted instanceof Uint8Array)) {
     if (devalueCodec.deserializeLegacy) {
       return devalueCodec.deserializeLegacy(decrypted, "step", options);
@@ -76805,6 +77250,7 @@ var init_step = __esm2({
     "use strict";
     init_dist2();
     init_codec_devalue();
+    init_compression();
     init_encryption2();
     init_errors3();
     init_format();
@@ -78864,6 +79310,20 @@ var init_capabilities = __esm2({
       {
         format: SerializationFormat.ENCRYPTED,
         minVersion: "4.2.0-beta.64"
+      },
+      // TODO(release): verify this matches the actual version that ships payload
+      // compression. If a "Version Packages (beta)" PR merges before this change,
+      // bump to the next beta. A too-low cutoff makes new producers write
+      // compressed payloads to consumers that cannot decompress them; too-high
+      // merely delays the optimization (safe). gzip and zstd ship together, so
+      // they share a min version — a run that can read one can read both.
+      {
+        format: SerializationFormat.GZIP,
+        minVersion: "5.0.0-beta.18"
+      },
+      {
+        format: SerializationFormat.ZSTD,
+        minVersion: "5.0.0-beta.18"
       }
     ];
     CAPABILITY_VERSION_TABLE = [
@@ -78882,7 +79342,7 @@ var version2;
 var init_version = __esm2({
   "../core/dist/version.js"() {
     "use strict";
-    version2 = "5.0.0-beta.17";
+    version2 = "5.0.0-beta.19";
   }
 });
 function getWorkflowQueueName(workflowName, namespace) {
@@ -80271,9 +80731,10 @@ async function resumeHook(tokenOrHook, payload, encryptionKeyOverride) {
         if (!capabilities.supportedFormats.has(SerializationFormat.ENCRYPTED)) {
           encryptionKey = void 0;
         }
+        const compression = (workflowRun.specVersion ?? 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);
+        const dehydratedPayload = await dehydrateStepReturnValue(payload, hook.runId, encryptionKey, 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", {
@@ -80406,6 +80867,25 @@ function unwrapSerializationCause(error482) {
   return error482;
 }
 __name(unwrapSerializationCause, "unwrapSerializationCause");
+async function recordCompression(stats, operation) {
+  if (!stats.recorded) return;
+  try {
+    const span = await getActiveSpan();
+    if (!span) return;
+    const uncompressedBytes = stats.uncompressedBytes ?? 0;
+    const storedBytes = stats.storedBytes ?? 0;
+    span.setAttributes({
+      ...SerializationOperation(operation),
+      ...SerializationCompressed(stats.compressed ?? false),
+      ...SerializationCodec(stats.codec ?? "none"),
+      ...SerializationUncompressedBytes(uncompressedBytes),
+      ...SerializationStoredBytes(storedBytes),
+      ...stats.compressed && uncompressedBytes > 0 ? SerializationCompressionRatio(1 - storedBytes / uncompressedBytes) : {}
+    });
+  } catch {
+  }
+}
+__name(recordCompression, "recordCompression");
 function getSerializeStream(reducers, cryptoKey) {
   const encoder22 = new TextEncoder();
   const keyState = {
@@ -81391,16 +81871,21 @@ async function maybeDecrypt(data, key) {
   return decrypt2(data, key);
 }
 __name(maybeDecrypt, "maybeDecrypt");
-async function dehydrateWorkflowArguments(value, runId, key, ops = [], global2 = globalThis, v1Compat = false, framedByteStreams = false) {
+async function dehydrateWorkflowArguments(value, runId, key, ops = [], global2 = globalThis, v1Compat = false, framedByteStreams = false, compression = false) {
   if (v1Compat) {
     const str = stringify(value, getExternalReducers(global2, ops, runId, key, framedByteStreams));
     return revive(str);
   }
   try {
-    return await serialize(value, key, {
+    const compressionStats = {};
+    const result = await serialize(value, key, {
       global: global2,
-      extraReducers: getStreamAndRequestReducers(getExternalReducers(global2, ops, runId, key, framedByteStreams))
+      extraReducers: getStreamAndRequestReducers(getExternalReducers(global2, ops, runId, key, framedByteStreams)),
+      compression,
+      compressionStats
     });
+    await recordCompression(compressionStats, "serialize");
+    return result;
   } catch (error482) {
     const cause = unwrapSerializationCause(error482);
     const { message, hint: hint22 } = formatSerializationError("workflow arguments", cause);
@@ -81412,25 +81897,34 @@ async function dehydrateWorkflowArguments(value, runId, key, ops = [], global2 =
 }
 __name(dehydrateWorkflowArguments, "dehydrateWorkflowArguments");
 async function hydrateWorkflowReturnValue(value, runId, key, ops = [], global2 = globalThis, extraRevivers = {}) {
-  return deserialize(value, key, {
+  const compressionStats = {};
+  const result = await deserialize(value, key, {
     global: global2,
     extraRevivers: {
       ...getStreamAndRequestRevivers(getExternalRevivers(global2, ops, runId, key)),
       ...extraRevivers
-    }
+    },
+    compressionStats
   });
+  await recordCompression(compressionStats, "deserialize");
+  return result;
 }
 __name(hydrateWorkflowReturnValue, "hydrateWorkflowReturnValue");
-async function dehydrateStepArguments(value, _runId, key, global2 = globalThis, v1Compat = false) {
+async function dehydrateStepArguments(value, _runId, key, global2 = globalThis, v1Compat = false, compression = false) {
   if (v1Compat) {
     const str = stringify(value, getWorkflowReducers(global2));
     return revive(str);
   }
   try {
-    return await serialize2(value, key, {
+    const compressionStats = {};
+    const result = await serialize2(value, key, {
       global: global2,
-      extraReducers: getStreamAndRequestReducers(getWorkflowReducers(global2))
+      extraReducers: getStreamAndRequestReducers(getWorkflowReducers(global2)),
+      compression,
+      compressionStats
     });
+    await recordCompression(compressionStats, "serialize");
+    return result;
   } catch (error482) {
     const cause = unwrapSerializationCause(error482);
     const { message, hint: hint22 } = formatSerializationError("step arguments", cause);
@@ -81442,25 +81936,34 @@ async function dehydrateStepArguments(value, _runId, key, global2 = globalThis,
 }
 __name(dehydrateStepArguments, "dehydrateStepArguments");
 async function hydrateStepArguments(value, runId, key, ops = [], global2 = globalThis, extraRevivers = {}, deploymentId) {
-  return deserialize2(value, key, {
+  const compressionStats = {};
+  const result = await deserialize2(value, key, {
     global: global2,
     extraRevivers: {
       ...getStreamAndRequestRevivers(getStepRevivers(global2, ops, runId, key, deploymentId)),
       ...extraRevivers
-    }
+    },
+    compressionStats
   });
+  await recordCompression(compressionStats, "deserialize");
+  return result;
 }
 __name(hydrateStepArguments, "hydrateStepArguments");
-async function dehydrateStepReturnValue(value, runId, key, ops = [], global2 = globalThis, v1Compat = false, framedByteStreams = false) {
+async function dehydrateStepReturnValue(value, runId, key, ops = [], global2 = globalThis, v1Compat = false, framedByteStreams = false, compression = false) {
   if (v1Compat) {
     const str = stringify(value, getStepReducers(global2, ops, runId, key, framedByteStreams));
     return revive(str);
   }
   try {
-    return await serialize2(value, key, {
+    const compressionStats = {};
+    const result = await serialize2(value, key, {
       global: global2,
-      extraReducers: getStreamAndRequestReducers(getStepReducers(global2, ops, runId, key, framedByteStreams))
+      extraReducers: getStreamAndRequestReducers(getStepReducers(global2, ops, runId, key, framedByteStreams)),
+      compression,
+      compressionStats
     });
+    await recordCompression(compressionStats, "serialize");
+    return result;
   } catch (error482) {
     const cause = unwrapSerializationCause(error482);
     const { message, hint: hint22 } = formatSerializationError("step return value", cause);
@@ -81472,7 +81975,9 @@ async function dehydrateStepReturnValue(value, runId, key, ops = [], global2 = g
 }
 __name(dehydrateStepReturnValue, "dehydrateStepReturnValue");
 async function hydrateRunError(value, runId, key, ops = [], global2 = globalThis, extraRevivers = {}) {
-  const decrypted = await maybeDecrypt(value, key);
+  const compressionStats = {};
+  const decrypted = await decompress(await maybeDecrypt(value, key), compressionStats);
+  await recordCompression(compressionStats, "deserialize");
   if (!(decrypted instanceof Uint8Array)) {
     return unflatten(decrypted, {
       ...getExternalRevivers(global2, ops, runId, key),
@@ -81530,6 +82035,7 @@ var init_serialization2 = __esm2({
     init_private();
     init_get_world_lazy();
     init_client();
+    init_compression();
     init_encryption2();
     init_errors3();
     init_format();
@@ -81541,12 +82047,15 @@ var init_serialization2 = __esm2({
     init_workflow();
     init_context_storage();
     init_symbols();
+    init_semantic_conventions();
+    init_telemetry();
     init_util2();
     init_abort_controller();
     defaultUlid = monotonicFactory();
     __name2(getStreamType, "getStreamType");
     FRAME_HEADER_SIZE = 4;
     __name2(unwrapSerializationCause, "unwrapSerializationCause");
+    __name2(recordCompression, "recordCompression");
     __name2(getSerializeStream, "getSerializeStream");
     __name2(getDeserializeStream, "getDeserializeStream");
     MAX_FRAME_SIZE = 1e8;
@@ -81877,6 +82386,7 @@ init_helpers();
 init_wait_until();
 var CROSS_DEPLOYMENT_CAPABILITY_PROBE_TIMEOUT_MS = 2e3;
 var ulid3 = monotonicFactory();
+var hasWarnedLatestNoOp = false;
 async function start(workflow, argsOrOptions, options) {
   return await waitedUntil(() => {
     const workflowName = workflow?.workflowId;
@@ -81905,22 +82415,34 @@ async function start(workflow, argsOrOptions, options) {
       const currentDeploymentId = await world.getDeploymentId();
       let deploymentId = opts.deploymentId ?? currentDeploymentId;
       if (deploymentId === "latest") {
-        if (!world.resolveLatestDeploymentId) {
-          throw new WorkflowRuntimeError("deploymentId 'latest' requires a World that implements resolveLatestDeploymentId()");
+        if (world.resolveLatestDeploymentId) {
+          deploymentId = await world.resolveLatestDeploymentId();
+        } else {
+          if (!hasWarnedLatestNoOp) {
+            hasWarnedLatestNoOp = true;
+            runtimeLogger.warn("deploymentId: 'latest' has no effect in this world and was ignored. It is only supported by worlds with atomic deployments, such as Vercel. The run will target the current deployment.", {
+              currentDeploymentId
+            });
+          }
+          deploymentId = currentDeploymentId;
         }
-        deploymentId = await world.resolveLatestDeploymentId();
       }
       let framedByteStreams;
+      let targetSupportsCompression;
       if (deploymentId === currentDeploymentId) {
         framedByteStreams = true;
+        targetSupportsCompression = true;
       } else if (typeof world.streams?.get !== "function") {
         framedByteStreams = false;
+        targetSupportsCompression = false;
       } else {
         const probe = await healthCheck(world, "workflow", {
           deploymentId,
           timeout: CROSS_DEPLOYMENT_CAPABILITY_PROBE_TIMEOUT_MS
         }).catch(() => void 0);
-        framedByteStreams = getRunCapabilities(probe?.workflowCoreVersion).framedByteStreams;
+        const capabilities = getRunCapabilities(probe?.workflowCoreVersion);
+        framedByteStreams = capabilities.framedByteStreams;
+        targetSupportsCompression = capabilities.supportedFormats.has(SerializationFormat.GZIP);
       }
       const ops = [];
       const runId = `wrun_${ulid3()}`;
@@ -81957,7 +82479,8 @@ async function start(workflow, argsOrOptions, options) {
         deploymentId
       });
       const encryptionKey = rawKey ? await importKey(rawKey) : void 0;
-      const workflowArguments = await dehydrateWorkflowArguments(args, runId, encryptionKey, ops, globalThis, v1Compat, framedByteStreams);
+      const compression = targetSupportsCompression && specVersion >= SPEC_VERSION_SUPPORTS_COMPRESSION;
+      const workflowArguments = await dehydrateWorkflowArguments(args, runId, encryptionKey, ops, globalThis, v1Compat, framedByteStreams, compression);
       const executionContext = {
         traceCarrier,
         workflowCoreVersion: version2,
@@ -82049,7 +82572,7 @@ __name2(start, "start");
     value: "start",
     configurable: true
   });
-})(start, "step//@workflow/core/runtime/start@5.0.0-beta.17//start");
+})(start, "step//@workflow/core/runtime/start@5.0.0-beta.19//start");
 function isRetryableStartError(err) {
   if (ThrottleError.is(err)) return true;
   if (WorkflowWorldError.is(err) && err.status && err.status >= 500) return true;
@@ -82383,7 +82906,7 @@ var Run = class _Run {
     value: "wakeUp",
     configurable: true
   });
-})(Run.prototype["wakeUp"], "step//@workflow/core/runtime/run@5.0.0-beta.17//Run#wakeUp");
+})(Run.prototype["wakeUp"], "step//@workflow/core/runtime/run@5.0.0-beta.19//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);
@@ -82392,7 +82915,7 @@ var Run = class _Run {
     value: "cancel",
     configurable: true
   });
-})(Run.prototype["cancel"], "step//@workflow/core/runtime/run@5.0.0-beta.17//Run#cancel");
+})(Run.prototype["cancel"], "step//@workflow/core/runtime/run@5.0.0-beta.19//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);
@@ -82401,7 +82924,7 @@ var Run = class _Run {
     value: "getReadable",
     configurable: true
   });
-})(Run.prototype["getReadable"], "step//@workflow/core/runtime/run@5.0.0-beta.17//Run#getReadable");
+})(Run.prototype["getReadable"], "step//@workflow/core/runtime/run@5.0.0-beta.19//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);
@@ -82410,7 +82933,7 @@ var Run = class _Run {
     value: "exists",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "exists").get, "step//@workflow/core/runtime/run@5.0.0-beta.17//Run#exists");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "exists").get, "step//@workflow/core/runtime/run@5.0.0-beta.19//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);
@@ -82419,7 +82942,7 @@ var Run = class _Run {
     value: "status",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "status").get, "step//@workflow/core/runtime/run@5.0.0-beta.17//Run#status");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "status").get, "step//@workflow/core/runtime/run@5.0.0-beta.19//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);
@@ -82428,7 +82951,7 @@ var Run = class _Run {
     value: "returnValue",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "returnValue").get, "step//@workflow/core/runtime/run@5.0.0-beta.17//Run#returnValue");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "returnValue").get, "step//@workflow/core/runtime/run@5.0.0-beta.19//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);
@@ -82437,7 +82960,7 @@ var Run = class _Run {
     value: "workflowName",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "workflowName").get, "step//@workflow/core/runtime/run@5.0.0-beta.17//Run#workflowName");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "workflowName").get, "step//@workflow/core/runtime/run@5.0.0-beta.19//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);
@@ -82446,7 +82969,7 @@ var Run = class _Run {
     value: "createdAt",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "createdAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.17//Run#createdAt");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "createdAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.19//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);
@@ -82455,7 +82978,7 @@ var Run = class _Run {
     value: "startedAt",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "startedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.17//Run#startedAt");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "startedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.19//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);
@@ -82464,7 +82987,7 @@ var Run = class _Run {
     value: "completedAt",
     configurable: true
   });
-})(Object.getOwnPropertyDescriptor(Run.prototype, "completedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.17//Run#completedAt");
+})(Object.getOwnPropertyDescriptor(Run.prototype, "completedAt").get, "step//@workflow/core/runtime/run@5.0.0-beta.19//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);
@@ -82474,7 +82997,7 @@ var Run = class _Run {
     enumerable: false,
     configurable: false
   });
-})(Run, "class//@workflow/core/runtime/run@5.0.0-beta.17//Run");
+})(Run, "class//@workflow/core/runtime/run@5.0.0-beta.19//Run");
 async function fetch2(...args) {
   return globalThis.fetch(...args);
 }
@@ -93300,7 +93823,7 @@ import os from "node:os";
 import { inspect } from "node:util";
 
 // ../world-vercel/dist/version.js
-var version5 = "5.0.0-beta.16";
+var version5 = "5.0.0-beta.18";
 
 // ../world-vercel/dist/utils.js
 var HTTP_DEBUG_ENABLED = typeof process !== "undefined" && typeof process.env.DEBUG === "string" && (process.env.DEBUG.includes("workflow:") || process.env.DEBUG === "*");
@@ -94086,11 +94609,14 @@ async function consumeListFrameStream(url3, headers, config4, opName) {
   const chunks = response.body;
   const events = [];
   let next2;
+  let hasMore;
   let sawEndSentinel = false;
   for await (const frame3 of decodeFrames(chunks)) {
     if (frame3.meta._end === 1) {
       if (typeof frame3.meta.next === "string")
         next2 = frame3.meta.next;
+      if (typeof frame3.meta.hasMore === "boolean")
+        hasMore = frame3.meta.hasMore;
       sawEndSentinel = true;
       break;
     }
@@ -94102,17 +94628,28 @@ async function consumeListFrameStream(url3, headers, config4, opName) {
   if (!sawEndSentinel) {
     throw new Error(`v4 ${opName}: frame stream ended without the end-of-stream sentinel (${events.length} events read) \u2014 truncated response?`);
   }
-  return { events, ...next2 ? { next: next2 } : {} };
+  return {
+    events,
+    ...next2 ? { next: next2 } : {},
+    ...hasMore !== void 0 ? { hasMore } : {}
+  };
 }
 __name(consumeListFrameStream, "consumeListFrameStream");
-function paginationToQuery(params) {
-  const sp = new URLSearchParams();
+function appendListParams(sp, params) {
   if (params.cursor)
     sp.set("cursor", params.cursor);
   if (params.limit !== void 0)
     sp.set("limit", String(params.limit));
   if (params.sortOrder)
     sp.set("sortOrder", params.sortOrder);
+  if (params.remoteRefBehavior) {
+    sp.set("remoteRefBehavior", params.remoteRefBehavior);
+  }
+}
+__name(appendListParams, "appendListParams");
+function paginationToQuery(params) {
+  const sp = new URLSearchParams();
+  appendListParams(sp, params);
   const qs = sp.toString();
   return qs ? `?${qs}` : "";
 }
@@ -94127,12 +94664,7 @@ async function getEventsByCorrelationIdV4(correlationId, params = {}, config4) {
   const { baseUrl, headers } = await getHttpConfig(config4);
   const sp = new URLSearchParams();
   sp.set("correlationId", correlationId);
-  if (params.cursor)
-    sp.set("cursor", params.cursor);
-  if (params.limit !== void 0)
-    sp.set("limit", String(params.limit));
-  if (params.sortOrder)
-    sp.set("sortOrder", params.sortOrder);
+  appendListParams(sp, params);
   const url3 = `${baseUrl}/v4/events?${sp.toString()}`;
   return consumeListFrameStream(url3, headers, config4, "listEventsByCorrelationId");
 }
@@ -94518,14 +95050,19 @@ async function getWorkflowRunEvents(params, config4) {
   const wirePagination = {
     cursor: pagination?.cursor ?? void 0,
     limit: pagination?.limit,
-    sortOrder: pagination?.sortOrder
+    sortOrder: pagination?.sortOrder,
+    remoteRefBehavior: resolveData === "none" ? "lazy" : "resolve"
   };
   const result = await ("correlationId" in params ? getEventsByCorrelationIdV4(params.correlationId, wirePagination, config4) : getWorkflowRunEventsV4(params.runId, wirePagination, config4));
   const events = result.events.map((listed) => buildEventFromV4(listed.event, listed.body, resolveData));
   return {
     data: events,
+    // `next` is present even on the final page (it's the incremental-load
+    // resume cursor), so prefer the server's explicit `hasMore`. The
+    // `Boolean(next)` fallback covers older servers that don't emit it —
+    // at the cost of one extra empty-page request per load.
     cursor: result.next ?? null,
-    hasMore: Boolean(result.next)
+    hasMore: typeof result.hasMore === "boolean" ? result.hasMore : Boolean(result.next)
   };
 }
 __name(getWorkflowRunEvents, "getWorkflowRunEvents");
@@ -94872,11 +95409,14 @@ __name(createStreamer2, "createStreamer");
 function createVercelWorld(config4) {
   const projectId = config4?.projectConfig?.projectId || process.env.VERCEL_PROJECT_ID;
   return {
-    // Spec v4: the workflow-server materializes native `attr_set` events
-    // and accepts initial run attributes on creation. New runs are stamped
-    // with this version; the server must be at least this version (it
-    // rejects runs newer than its own SPEC_VERSION_CURRENT).
-    specVersion: SPEC_VERSION_SUPPORTS_ATTRIBUTES2,
+    // Spec v5: new runs may carry gzip-compressed payloads (compression is
+    // entirely client-side — the workflow-server stores payloads opaquely
+    // via RemoteRef and never deserializes them). Spec 5 is a superset of
+    // spec 4, so native `attr_set` events and initial run attributes still
+    // work. New runs are stamped with this version; the server must support
+    // at least it — workflow-server declared spec-5 support in
+    // vercel/workflow-server#520.
+    specVersion: SPEC_VERSION_SUPPORTS_COMPRESSION2,
     // On Vercel the platform fails the function invocation when the
     // process exits non-zero, and VQS redelivers the queue message via a
     // fresh invocation. The core runtime uses this to decide whether
@@ -95243,6 +95783,7 @@ var DEFAULT_STEP_MAX_RETRIES = 3;
 async function executeStep(params) {
   const { world, workflowRunId, workflowName, workflowStartedAt, stepId, stepName } = params;
   const isVercel = process.env.VERCEL_URL !== void 0;
+  const compression = (params.runSpecVersion ?? 0) >= SPEC_VERSION_SUPPORTS_COMPRESSION2;
   const spanName = `step.execute ${stepDisplayName(stepName)}`;
   return trace3(spanName, {}, async (span) => {
     span?.setAttributes({
@@ -95267,7 +95808,7 @@ async function executeStep(params) {
           correlationId: stepId,
           eventData: {
             stepName,
-            error: await dehydrateStepError(new FatalError2(errorMessage), workflowRunId, await getEncryptionKey())
+            error: await dehydrateStepError(new FatalError2(errorMessage), workflowRunId, await getEncryptionKey(), [], globalThis, compression)
           }
         });
       } catch (stepFailErr) {
@@ -95366,7 +95907,7 @@ async function executeStep(params) {
           correlationId: stepId,
           eventData: {
             stepName,
-            error: await dehydrateStepError(wrappedError, workflowRunId, await getEncryptionKey())
+            error: await dehydrateStepError(wrappedError, workflowRunId, await getEncryptionKey(), [], globalThis, compression)
           }
         });
       } catch (err) {
@@ -95436,7 +95977,7 @@ async function executeStep(params) {
       });
       result = await trace3("step.dehydrate", {}, async (dehydrateSpan) => {
         const startTime = Date.now();
-        const dehydrated = await dehydrateStepReturnValue2(result, workflowRunId, encryptionKey, ops);
+        const dehydrated = await dehydrateStepReturnValue2(result, workflowRunId, encryptionKey, ops, globalThis, false, false, compression);
         const durationMs = Date.now() - startTime;
         dehydrateSpan?.setAttributes({
           ...QueueSerializeTimeMs2(durationMs),
@@ -95536,7 +96077,7 @@ async function executeStep(params) {
             correlationId: stepId,
             eventData: {
               stepName,
-              error: await dehydrateStepError(effectiveErr, workflowRunId, await getEncryptionKey())
+              error: await dehydrateStepError(effectiveErr, workflowRunId, await getEncryptionKey(), [], globalThis, compression)
             }
           });
         } catch (stepFailErr) {
@@ -95583,7 +96124,7 @@ async function executeStep(params) {
             correlationId: stepId,
             eventData: {
               stepName,
-              error: await dehydrateStepError(wrappedError, workflowRunId, await getEncryptionKey())
+              error: await dehydrateStepError(wrappedError, workflowRunId, await getEncryptionKey(), [], globalThis, compression)
             }
           });
         } catch (stepFailErr) {
@@ -95629,7 +96170,7 @@ async function executeStep(params) {
           correlationId: stepId,
           eventData: {
             stepName,
-            error: await dehydrateStepError(err, workflowRunId, await getEncryptionKey()),
+            error: await dehydrateStepError(err, workflowRunId, await getEncryptionKey(), [], globalThis, compression),
             ...RetryableError2.is(err) && { retryAfter: err.retryAfter }
           }
         });
@@ -95714,8 +96255,9 @@ async function handleSuspension({ suspension, world, run: run3, span, requestId
   const hooksNeedingDisposal = allHookItems.filter((item) => item.disposed);
   const rawKey = await world.getEncryptionKeyForRun?.(run3);
   const encryptionKey = rawKey ? await importKey2(rawKey) : void 0;
+  const compression = (run3.specVersion ?? 0) >= SPEC_VERSION_SUPPORTS_COMPRESSION2;
   const hookEvents = await Promise.all(hooksNeedingCreation.map(async (queueItem) => {
-    const hookMetadata = typeof queueItem.metadata === "undefined" ? void 0 : await dehydrateStepArguments2(queueItem.metadata, runId, encryptionKey, suspension.globalThis);
+    const hookMetadata = typeof queueItem.metadata === "undefined" ? void 0 : await dehydrateStepArguments2(queueItem.metadata, runId, encryptionKey, suspension.globalThis, false, compression);
     return {
       queueItem,
       hookEvent: {
@@ -95785,7 +96327,7 @@ async function handleSuspension({ suspension, world, run: run3, span, requestId
   if (hooksNeedingAbort.length > 0) {
     await Promise.all(hooksNeedingAbort.map(async (queueItem) => {
       try {
-        const abortPayload = await dehydrateStepArguments2({ aborted: true, reason: queueItem.abortReason }, runId, encryptionKey, suspension.globalThis);
+        const abortPayload = await dehydrateStepArguments2({ aborted: true, reason: queueItem.abortReason }, runId, encryptionKey, suspension.globalThis, false, compression);
         await world.events.create(runId, {
           eventType: "hook_received",
           specVersion: SPEC_VERSION_CURRENT2,
@@ -95828,7 +96370,7 @@ async function handleSuspension({ suspension, world, run: run3, span, requestId
           args: queueItem.args,
           closureVars: queueItem.closureVars,
           thisVal: queueItem.thisVal
-        }, runId, encryptionKey, suspension.globalThis);
+        }, runId, encryptionKey, suspension.globalThis, false, compression);
         const stepEvent = {
           eventType: "step_created",
           specVersion: SPEC_VERSION_CURRENT2,
@@ -96557,6 +97099,7 @@ init_util4();
 init_dist6();
 init_dist5();
 init_parse_name2();
+init_dist7();
 import { runInContext as runInContext2 } from "node:vm";
 
 // ../../node_modules/.pnpm/nanoid@5.1.6/node_modules/nanoid/url-alphabet/index.js
@@ -98141,7 +98684,17 @@ Learn more: https://workflow-sdk.dev/err/${ERROR_SLUGS2.FETCH_IN_WORKFLOW_FUNCTI
         workflowFn(...args),
         workflowDiscontinuation.promise
       ]);
-      const dehydrated = await dehydrateWorkflowReturnValue(result, workflowRun.runId, encryptionKey, vmGlobalThis);
+      const dehydrated = await dehydrateWorkflowReturnValue(
+        result,
+        workflowRun.runId,
+        encryptionKey,
+        vmGlobalThis,
+        false,
+        // Gate payload compression on the run's specVersion: only runs
+        // marked as possibly containing compressed payloads (spec >= 5)
+        // get gzip data.
+        (workflowRun.specVersion ?? 0) >= SPEC_VERSION_SUPPORTS_COMPRESSION2
+      );
       span?.setAttributes({
         ...WorkflowResultType2(typeof result)
       });
@@ -98531,7 +99084,7 @@ async function recordFatalRunError({ world, workflowRun, runId, requestId, err,
       eventType: "run_failed",
       specVersion: SPEC_VERSION_CURRENT2,
       eventData: {
-        error: await dehydrateRunError(err, runId, await getEncryptionKey()),
+        error: await dehydrateRunError(err, runId, await getEncryptionKey(), globalThis, (workflowRun?.specVersion ?? 0) >= SPEC_VERSION_SUPPORTS_COMPRESSION2),
         errorCode
       }
     }, { requestId });
@@ -98659,7 +99212,8 @@ function workflowEntrypoint(workflowCode2, options) {
                   workflowName,
                   workflowStartedAt: bgStartedAt,
                   stepId: incomingStepId,
-                  stepName: incomingStepName
+                  stepName: incomingStepName,
+                  runSpecVersion: bgRun.specVersion
                 });
               } finally {
                 replayBudget.resume();
@@ -98985,7 +99539,7 @@ function workflowEntrypoint(workflowCode2, options) {
                       eventType: "run_failed",
                       specVersion: SPEC_VERSION_CURRENT2,
                       eventData: {
-                        error: await dehydrateRunError(suspensionError, runId, encryptionKey),
+                        error: await dehydrateRunError(suspensionError, runId, encryptionKey, globalThis, (workflowRun?.specVersion ?? 0) >= SPEC_VERSION_SUPPORTS_COMPRESSION2),
                         errorCode
                       }
                     }, { requestId });
@@ -99066,7 +99620,8 @@ function workflowEntrypoint(workflowCode2, options) {
                     workflowName,
                     workflowStartedAt,
                     stepId: inlineStep.correlationId,
-                    stepName: inlineStep.stepName
+                    stepName: inlineStep.stepName,
+                    runSpecVersion: workflowRun.specVersion
                   });
                 } finally {
                   replayBudget.resume();
@@ -99156,7 +99711,7 @@ function workflowEntrypoint(workflowCode2, options) {
                     eventType: "run_failed",
                     specVersion: SPEC_VERSION_CURRENT2,
                     eventData: {
-                      error: await dehydrateRunError(terminalError, runId, encryptionKey),
+                      error: await dehydrateRunError(terminalError, runId, encryptionKey, globalThis, (workflowRun?.specVersion ?? 0) >= SPEC_VERSION_SUPPORTS_COMPRESSION2),
                       errorCode
                     }
                   }, { requestId });
@@ -115470,10 +116025,10 @@ var Run = class _Run {
     return this.getReadable();
   }
 };
-Run.prototype["wakeUp"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.17//Run#wakeUp");
-Run.prototype["cancel"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.17//Run#cancel");
-Run.prototype["getReadable"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.17//Run#getReadable");
-var __step_Run$exists = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.17//Run#exists");
+Run.prototype["wakeUp"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.19//Run#wakeUp");
+Run.prototype["cancel"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.19//Run#cancel");
+Run.prototype["getReadable"] = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.19//Run#getReadable");
+var __step_Run$exists = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.19//Run#exists");
 Object.defineProperty(Run.prototype, "exists", {
   get() {
     return __step_Run$exists.call(this);
@@ -115481,7 +116036,7 @@ Object.defineProperty(Run.prototype, "exists", {
   configurable: true,
   enumerable: false
 });
-var __step_Run$status = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.17//Run#status");
+var __step_Run$status = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.19//Run#status");
 Object.defineProperty(Run.prototype, "status", {
   get() {
     return __step_Run$status.call(this);
@@ -115489,7 +116044,7 @@ Object.defineProperty(Run.prototype, "status", {
   configurable: true,
   enumerable: false
 });
-var __step_Run$returnValue = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.17//Run#returnValue");
+var __step_Run$returnValue = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.19//Run#returnValue");
 Object.defineProperty(Run.prototype, "returnValue", {
   get() {
     return __step_Run$returnValue.call(this);
@@ -115497,7 +116052,7 @@ Object.defineProperty(Run.prototype, "returnValue", {
   configurable: true,
   enumerable: false
 });
-var __step_Run$workflowName = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.17//Run#workflowName");
+var __step_Run$workflowName = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.19//Run#workflowName");
 Object.defineProperty(Run.prototype, "workflowName", {
   get() {
     return __step_Run$workflowName.call(this);
@@ -115505,7 +116060,7 @@ Object.defineProperty(Run.prototype, "workflowName", {
   configurable: true,
   enumerable: false
 });
-var __step_Run$createdAt = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.17//Run#createdAt");
+var __step_Run$createdAt = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.19//Run#createdAt");
 Object.defineProperty(Run.prototype, "createdAt", {
   get() {
     return __step_Run$createdAt.call(this);
@@ -115513,7 +116068,7 @@ Object.defineProperty(Run.prototype, "createdAt", {
   configurable: true,
   enumerable: false
 });
-var __step_Run$startedAt = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.17//Run#startedAt");
+var __step_Run$startedAt = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.19//Run#startedAt");
 Object.defineProperty(Run.prototype, "startedAt", {
   get() {
     return __step_Run$startedAt.call(this);
@@ -115521,7 +116076,7 @@ Object.defineProperty(Run.prototype, "startedAt", {
   configurable: true,
   enumerable: false
 });
-var __step_Run$completedAt = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.17//Run#completedAt");
+var __step_Run$completedAt = globalThis[/* @__PURE__ */ Symbol.for("WORKFLOW_USE_STEP")]("step//@workflow/core/runtime/run@5.0.0-beta.19//Run#completedAt");
 Object.defineProperty(Run.prototype, "completedAt", {
   get() {
     return __step_Run$completedAt.call(this);
@@ -115538,7 +116093,7 @@ Object.defineProperty(Run.prototype, "completedAt", {
     enumerable: false,
     configurable: false
   });
-})(Run, "class//@workflow/core/runtime/run@5.0.0-beta.17//Run");
+})(Run, "class//@workflow/core/runtime/run@5.0.0-beta.19//Run");
 
 // ../core/dist/workflow/create-hook.js
 aliasSerializationClass(RUN_CLASS_ID, Run);