@workflow/core 5.0.0-beta.42 → 5.0.0-beta.44

package/dist/serialization/codec-devalue.js

@@ -5,7 +5,7 @@
  * reducers (serialize) and revivers (deserialize) which are composed
  * internally based on the serialization mode.
  *
- * The reducer/reviver pattern is specific to devalue — other codecs
+ * The reducer/reviver pattern is specific to devalue: other codecs
  * (CBOR, JSON) would handle types differently (e.g. CBOR supports Date,
  * typed arrays, Map, Set natively).
  */
@@ -113,4 +113,4 @@ export const devalueCodec = {
         return unflatten(data, revivers, parseOptions);
     },
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"codec-devalue.js","sourceRoot":"","sources":["../../src/serialization/codec-devalue.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Devalue codec implementation.\n *\n * Uses the `devalue` library for serialization. Handles custom types via\n * reducers (serialize) and revivers (deserialize) which are composed\n * internally based on the serialization mode.\n *\n * The reducer/reviver pattern is specific to devalue — other codecs\n * (CBOR, JSON) would handle types differently (e.g. CBOR supports Date,\n * typed arrays, Map, Set natively).\n */\n\nimport {\n  defaultParseOperations,\n  type ParseOptions,\n  parse,\n  stringify,\n  unflatten,\n} from 'devalue';\nimport type { Codec, CodecOptions, SerializationMode } from './codec.js';\nimport { hardenedStringifyOperations, withGuestCodeStats } from './hardened.js';\nimport { getClassReducers, getClassRevivers } from './reducers/class.js';\nimport { getCommonReducers, getCommonRevivers } from './reducers/common.js';\nimport {\n  getStepFunctionReducer,\n  getStepFunctionReviver,\n} from './reducers/step-function.js';\nimport { type Reducers, type Revivers, SerializationFormat } from './types.js';\n\nconst encoder = new TextEncoder();\nconst decoder = new TextDecoder();\nconst MAX_SPARSE_ARRAY_LENGTH = 100_000;\n\nconst parseOptions = {\n  operations: {\n    createSparseArray(length) {\n      if (length > MAX_SPARSE_ARRAY_LENGTH) {\n        throw new RangeError(\n          `Sparse array length ${length} exceeds the maximum of ${MAX_SPARSE_ARRAY_LENGTH}`\n        );\n      }\n      return defaultParseOperations.createSparseArray(length);\n    },\n  },\n} satisfies ParseOptions;\n\n// ---- Reducer/Reviver composition per mode ----\n\nfunction getReducersForMode(\n  mode: SerializationMode,\n  global: Record<string, any> = globalThis,\n  extraReducers?: Record<string, (value: any) => any>\n): Record<string, (value: any) => any> {\n  let base: Partial<Reducers>;\n  switch (mode) {\n    case 'workflow':\n      // Class/Instance MUST come before common (first-match-wins for Error subclasses)\n      base = {\n        ...getClassReducers(),\n        ...getStepFunctionReducer(),\n        ...getCommonReducers(global),\n      };\n      break;\n    case 'step':\n      base = {\n        ...getClassReducers(),\n        ...getCommonReducers(global),\n      };\n      break;\n    case 'client':\n      base = {\n        ...getClassReducers(),\n        ...getCommonReducers(global),\n      };\n      break;\n  }\n  if (extraReducers) {\n    return { ...base, ...extraReducers } as Record<string, (value: any) => any>;\n  }\n  return base as Record<string, (value: any) => any>;\n}\n\nfunction getReviversForMode(\n  mode: SerializationMode,\n  global: Record<string, any> = globalThis,\n  extraRevivers?: Record<string, (value: any) => any>\n): Record<string, (value: any) => any> {\n  let base: Partial<Revivers>;\n  switch (mode) {\n    case 'workflow':\n      base = {\n        ...getClassRevivers(global),\n        ...getStepFunctionReviver(global),\n        ...getCommonRevivers(global),\n      };\n      break;\n    case 'step':\n      base = {\n        ...getClassRevivers(global),\n        ...getCommonRevivers(global),\n      };\n      break;\n    case 'client':\n      base = {\n        ...getClassRevivers(global),\n        ...getCommonRevivers(global),\n        StepFunction: () => {\n          throw new Error(\n            'Step functions cannot be deserialized in client context.'\n          );\n        },\n      };\n      break;\n  }\n  if (extraRevivers) {\n    return { ...base, ...extraRevivers } as Record<string, (value: any) => any>;\n  }\n  return base as Record<string, (value: any) => any>;\n}\n\n// ---- Codec implementation ----\n\nexport const devalueCodec: Codec = {\n  formatPrefix: SerializationFormat.DEVALUE_V1,\n\n  serialize(\n    value: unknown,\n    mode: SerializationMode,\n    options?: CodecOptions\n  ): Uint8Array {\n    const reducers = getReducersForMode(\n      mode,\n      options?.global,\n      options?.extraReducers\n    );\n    // Hardened operations: devalue's own introspection (classification,\n    // built-in extraction, property reads) goes through captured host\n    // intrinsics and descriptor reads, so serializing a value constructed\n    // inside a workflow VM cannot execute sandbox code behind our back.\n    // Where workflow code must run (getters, proxies, custom serializers),\n    // the execution is recorded into `options.guestCodeStats`.\n    const str = withGuestCodeStats(options?.guestCodeStats, () =>\n      stringify(value, reducers, { operations: hardenedStringifyOperations })\n    );\n    return encoder.encode(str);\n  },\n\n  deserialize(\n    data: Uint8Array,\n    mode: SerializationMode,\n    options?: CodecOptions\n  ): unknown {\n    const revivers = getReviversForMode(\n      mode,\n      options?.global,\n      options?.extraRevivers\n    );\n    const str = decoder.decode(data);\n    return parse(str, revivers, parseOptions);\n  },\n\n  deserializeLegacy(\n    data: unknown,\n    mode: SerializationMode,\n    options?: CodecOptions\n  ): unknown {\n    const revivers = getReviversForMode(\n      mode,\n      options?.global,\n      options?.extraRevivers\n    );\n    return unflatten(data as any[], revivers, parseOptions);\n  },\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"codec-devalue.js","sourceRoot":"","sources":["../../src/serialization/codec-devalue.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Devalue codec implementation.\n *\n * Uses the `devalue` library for serialization. Handles custom types via\n * reducers (serialize) and revivers (deserialize) which are composed\n * internally based on the serialization mode.\n *\n * The reducer/reviver pattern is specific to devalue: other codecs\n * (CBOR, JSON) would handle types differently (e.g. CBOR supports Date,\n * typed arrays, Map, Set natively).\n */\n\nimport {\n  defaultParseOperations,\n  type ParseOptions,\n  parse,\n  stringify,\n  unflatten,\n} from 'devalue';\nimport type { Codec, CodecOptions, SerializationMode } from './codec.js';\nimport { hardenedStringifyOperations, withGuestCodeStats } from './hardened.js';\nimport { getClassReducers, getClassRevivers } from './reducers/class.js';\nimport { getCommonReducers, getCommonRevivers } from './reducers/common.js';\nimport {\n  getStepFunctionReducer,\n  getStepFunctionReviver,\n} from './reducers/step-function.js';\nimport { type Reducers, type Revivers, SerializationFormat } from './types.js';\n\nconst encoder = new TextEncoder();\nconst decoder = new TextDecoder();\nconst MAX_SPARSE_ARRAY_LENGTH = 100_000;\n\nconst parseOptions = {\n  operations: {\n    createSparseArray(length) {\n      if (length > MAX_SPARSE_ARRAY_LENGTH) {\n        throw new RangeError(\n          `Sparse array length ${length} exceeds the maximum of ${MAX_SPARSE_ARRAY_LENGTH}`\n        );\n      }\n      return defaultParseOperations.createSparseArray(length);\n    },\n  },\n} satisfies ParseOptions;\n\n// ---- Reducer/Reviver composition per mode ----\n\nfunction getReducersForMode(\n  mode: SerializationMode,\n  global: Record<string, any> = globalThis,\n  extraReducers?: Record<string, (value: any) => any>\n): Record<string, (value: any) => any> {\n  let base: Partial<Reducers>;\n  switch (mode) {\n    case 'workflow':\n      // Class/Instance MUST come before common (first-match-wins for Error subclasses)\n      base = {\n        ...getClassReducers(),\n        ...getStepFunctionReducer(),\n        ...getCommonReducers(global),\n      };\n      break;\n    case 'step':\n      base = {\n        ...getClassReducers(),\n        ...getCommonReducers(global),\n      };\n      break;\n    case 'client':\n      base = {\n        ...getClassReducers(),\n        ...getCommonReducers(global),\n      };\n      break;\n  }\n  if (extraReducers) {\n    return { ...base, ...extraReducers } as Record<string, (value: any) => any>;\n  }\n  return base as Record<string, (value: any) => any>;\n}\n\nfunction getReviversForMode(\n  mode: SerializationMode,\n  global: Record<string, any> = globalThis,\n  extraRevivers?: Record<string, (value: any) => any>\n): Record<string, (value: any) => any> {\n  let base: Partial<Revivers>;\n  switch (mode) {\n    case 'workflow':\n      base = {\n        ...getClassRevivers(global),\n        ...getStepFunctionReviver(global),\n        ...getCommonRevivers(global),\n      };\n      break;\n    case 'step':\n      base = {\n        ...getClassRevivers(global),\n        ...getCommonRevivers(global),\n      };\n      break;\n    case 'client':\n      base = {\n        ...getClassRevivers(global),\n        ...getCommonRevivers(global),\n        StepFunction: () => {\n          throw new Error(\n            'Step functions cannot be deserialized in client context.'\n          );\n        },\n      };\n      break;\n  }\n  if (extraRevivers) {\n    return { ...base, ...extraRevivers } as Record<string, (value: any) => any>;\n  }\n  return base as Record<string, (value: any) => any>;\n}\n\n// ---- Codec implementation ----\n\nexport const devalueCodec: Codec = {\n  formatPrefix: SerializationFormat.DEVALUE_V1,\n\n  serialize(\n    value: unknown,\n    mode: SerializationMode,\n    options?: CodecOptions\n  ): Uint8Array {\n    const reducers = getReducersForMode(\n      mode,\n      options?.global,\n      options?.extraReducers\n    );\n    // Hardened operations: devalue's own introspection (classification,\n    // built-in extraction, property reads) goes through captured host\n    // intrinsics and descriptor reads, so serializing a value constructed\n    // inside a workflow VM cannot execute sandbox code behind our back.\n    // Where workflow code must run (getters, proxies, custom serializers),\n    // the execution is recorded into `options.guestCodeStats`.\n    const str = withGuestCodeStats(options?.guestCodeStats, () =>\n      stringify(value, reducers, { operations: hardenedStringifyOperations })\n    );\n    return encoder.encode(str);\n  },\n\n  deserialize(\n    data: Uint8Array,\n    mode: SerializationMode,\n    options?: CodecOptions\n  ): unknown {\n    const revivers = getReviversForMode(\n      mode,\n      options?.global,\n      options?.extraRevivers\n    );\n    const str = decoder.decode(data);\n    return parse(str, revivers, parseOptions);\n  },\n\n  deserializeLegacy(\n    data: unknown,\n    mode: SerializationMode,\n    options?: CodecOptions\n  ): unknown {\n    const revivers = getReviversForMode(\n      mode,\n      options?.global,\n      options?.extraRevivers\n    );\n    return unflatten(data as any[], revivers, parseOptions);\n  },\n};\n"]}

package/dist/serialization/codec.d.ts

@@ -3,7 +3,7 @@
  *
  * A codec handles the core serialize/deserialize logic for a specific
  * wire format (devalue, CBOR, JSON, etc.). Each codec is responsible
- * for handling all supported data types internally — the caller only
+ * for handling all supported data types internally; the caller only
  * specifies which serialization mode to use.
  *
  * - **devalue**: Uses custom reducers/revivers for Date, Error, Map, Set,
@@ -70,15 +70,15 @@ export interface CodecOptions {
     compressionStats?: CompressionStats;
     /**
      * Optional sink populated by the hardened serializer with every
-     * workflow (guest) code execution that serialization could not avoid —
+     * workflow (guest) code execution that serialization could not avoid:
      * getters, proxies, and custom `[WORKFLOW_SERIALIZE]` methods. A non-empty
      * `executions` array means serialization may have perturbed VM state
      * (it runs exactly once per payload and is never replayed, so any side
      * effect it triggers diverges from replay).
      *
      * Every dehydrate path already reports this as span attributes. Passing a
-     * sink is for callers that need the executions *programmatically* — a
-     * retained-VM gate deciding whether the VM is still reusable. No caller
+     * sink is for callers that need the executions *programmatically*, such
+     * as a retained-VM gate deciding whether the VM is still reusable. No caller
      * does that yet, so nothing in the runtime currently passes one.
      *
      * Serialize side only.

package/dist/serialization/codec.js

@@ -3,7 +3,7 @@
  *
  * A codec handles the core serialize/deserialize logic for a specific
  * wire format (devalue, CBOR, JSON, etc.). Each codec is responsible
- * for handling all supported data types internally — the caller only
+ * for handling all supported data types internally; the caller only
  * specifies which serialization mode to use.
  *
  * - **devalue**: Uses custom reducers/revivers for Date, Error, Map, Set,
@@ -14,4 +14,4 @@
  *   plain objects). No Date, Map, Set, typed arrays, etc.
  */
 export {};
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/serialization/compression.d.ts

@@ -5,22 +5,23 @@
  * format prefix system to mark compressed data (e.g. 'zstd' or 'gzip'
  * wrapping the inner format: 'zstd' + zstd('devl' + payload)).
  *
- * Codec selection (write side): zstd is preferred — it is markedly faster
- * than gzip at a comparable-or-better ratio (see scripts/README.md), and
- * compression runs at every step boundary so the write CPU is a per-step
- * tax. zstd requires `node:zlib` >= 22.15 (Web `CompressionStream` has no
- * zstd), so on a runtime without it we fall back to gzip via the portable
+ * Codec selection (write side): zstd is preferred because it is markedly
+ * faster than gzip at a comparable-or-better ratio (see scripts/README.md),
+ * and compression runs at every step boundary so the write CPU is a
+ * per-step tax. zstd requires `node:zlib` >= 22.15 (Web
+ * `CompressionStream` has no zstd), so on a runtime without it we fall back
+ * to gzip via the portable
  * `CompressionStream`. `WORKFLOW_COMPRESSION_CODEC=gzip` forces the
  * portable codec.
  *
  * Read side: dispatch on the format prefix, so both 'zstd' and 'gzip'
  * payloads are always decodable regardless of which codec wrote them.
- * (The browser o11y read path decodes zstd via a registered WASM decoder —
+ * (The browser o11y read path decodes zstd via a registered WASM decoder,
  * see `serialization-format.ts`; this module's `decompress` is the Node
  * runtime/replay path and uses `node:zlib`.)
  *
  * Layering order with encryption: compression is applied BEFORE
- * encryption (encr(zstd(devl))) — encrypted bytes are high-entropy and
+ * encryption (encr(zstd(devl))): encrypted bytes are high-entropy and
  * do not compress, so the reverse order would be a no-op.
  *
  * Compression is conditional:
@@ -50,8 +51,8 @@ export type CompressionCodec = 'zstd' | 'gzip' | 'none';
  * Telemetry sink describing what the compression layer did to a payload.
  * Populated by {@link compress} (write) and {@link decompress} (read) when
  * a `stats` object is passed. Sizes are measured at the compression
- * boundary — i.e. before encryption is layered on the write side and after
- * decryption on the read side — so they reflect compression's effect, not
+ * boundary (i.e. before encryption is layered on the write side and after
+ * decryption on the read side), so they reflect compression's effect, not
  * the at-rest size (which also includes the `encr` envelope and, on some
  * backends, base64 expansion).
  *
@@ -80,8 +81,8 @@ export interface CompressionStats {
  * @param data - The format-prefixed serialized data (e.g. 'devl' + bytes)
  * @param enabled - Whether the target run supports compressed payloads
  *   (run specVersion >= SPEC_VERSION_SUPPORTS_COMPRESSION, and for
- *   cross-deployment writes, the target deployment's capabilities —
- *   see `getRunCapabilities` in capabilities.ts). zstd and gzip read
+ *   cross-deployment writes, the target deployment's capabilities; see
+ *   `getRunCapabilities` in capabilities.ts). zstd and gzip read
  *   support co-ship, so a single boolean is sufficient.
  * @param stats - Optional telemetry sink; populated when `data` is binary.
  * @returns The compressed data with a codec prefix, or the original data

package/dist/serialization/compression.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compression.d.ts","sourceRoot":"","sources":["../../src/serialization/compression.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AASH;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,OAAO,CAAC;AAE1C;;;;;GAKG;AACH,eAAO,MAAM,6BAA6B,OAAO,CAAC;AAKlD,6EAA6E;AAC7E,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;AA4IxD;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,gBAAgB;IAC/B,kEAAkE;IAClE,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,6DAA6D;IAC7D,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,yCAAyC;IACzC,KAAK,CAAC,EAAE,gBAAgB,CAAC;IACzB,mDAAmD;IACnD,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,uDAAuD;IACvD,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AA6BD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,QAAQ,CAC5B,IAAI,EAAE,UAAU,GAAG,OAAO,EAC1B,OAAO,EAAE,OAAO,EAChB,KAAK,CAAC,EAAE,gBAAgB,GACvB,OAAO,CAAC,UAAU,GAAG,OAAO,CAAC,CA4B/B;AAED;;;;;;;GAOG;AACH,wBAAsB,UAAU,CAC9B,IAAI,EAAE,UAAU,GAAG,OAAO,EAC1B,KAAK,CAAC,EAAE,gBAAgB,GACvB,OAAO,CAAC,UAAU,GAAG,OAAO,CAAC,CA2B/B;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,GAAG,OAAO,CAKhE"}
+{"version":3,"file":"compression.d.ts","sourceRoot":"","sources":["../../src/serialization/compression.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AASH;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,OAAO,CAAC;AAE1C;;;;;GAKG;AACH,eAAO,MAAM,6BAA6B,OAAO,CAAC;AAKlD,6EAA6E;AAC7E,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;AA4IxD;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,gBAAgB;IAC/B,kEAAkE;IAClE,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,6DAA6D;IAC7D,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,yCAAyC;IACzC,KAAK,CAAC,EAAE,gBAAgB,CAAC;IACzB,mDAAmD;IACnD,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,uDAAuD;IACvD,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AA6BD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,QAAQ,CAC5B,IAAI,EAAE,UAAU,GAAG,OAAO,EAC1B,OAAO,EAAE,OAAO,EAChB,KAAK,CAAC,EAAE,gBAAgB,GACvB,OAAO,CAAC,UAAU,GAAG,OAAO,CAAC,CA4B/B;AAED;;;;;;;GAOG;AACH,wBAAsB,UAAU,CAC9B,IAAI,EAAE,UAAU,GAAG,OAAO,EAC1B,KAAK,CAAC,EAAE,gBAAgB,GACvB,OAAO,CAAC,UAAU,GAAG,OAAO,CAAC,CA2B/B;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,GAAG,OAAO,CAKhE"}

package/dist/serialization/compression.js

@@ -5,22 +5,23 @@
  * format prefix system to mark compressed data (e.g. 'zstd' or 'gzip'
  * wrapping the inner format: 'zstd' + zstd('devl' + payload)).
  *
- * Codec selection (write side): zstd is preferred — it is markedly faster
- * than gzip at a comparable-or-better ratio (see scripts/README.md), and
- * compression runs at every step boundary so the write CPU is a per-step
- * tax. zstd requires `node:zlib` >= 22.15 (Web `CompressionStream` has no
- * zstd), so on a runtime without it we fall back to gzip via the portable
+ * Codec selection (write side): zstd is preferred because it is markedly
+ * faster than gzip at a comparable-or-better ratio (see scripts/README.md),
+ * and compression runs at every step boundary so the write CPU is a
+ * per-step tax. zstd requires `node:zlib` >= 22.15 (Web
+ * `CompressionStream` has no zstd), so on a runtime without it we fall back
+ * to gzip via the portable
  * `CompressionStream`. `WORKFLOW_COMPRESSION_CODEC=gzip` forces the
  * portable codec.
  *
  * Read side: dispatch on the format prefix, so both 'zstd' and 'gzip'
  * payloads are always decodable regardless of which codec wrote them.
- * (The browser o11y read path decodes zstd via a registered WASM decoder —
+ * (The browser o11y read path decodes zstd via a registered WASM decoder,
  * see `serialization-format.ts`; this module's `decompress` is the Node
  * runtime/replay path and uses `node:zlib`.)
  *
  * Layering order with encryption: compression is applied BEFORE
- * encryption (encr(zstd(devl))) — encrypted bytes are high-entropy and
+ * encryption (encr(zstd(devl))): encrypted bytes are high-entropy and
  * do not compress, so the reverse order would be a no-op.
  *
  * Compression is conditional:
@@ -46,11 +47,11 @@ export const COMPRESSION_MIN_BYTES = 1024;
  * data paying a permanent decompression tax for a negligible win.
  */
 export const COMPRESSION_MIN_SAVINGS_RATIO = 0.05;
-/** Default zstd compression level — the sweet spot of speed vs ratio. */
+/** Default zstd compression level: the sweet spot of speed vs ratio. */
 const ZSTD_LEVEL = 3;
 /**
  * Escape hatch: set WORKFLOW_DISABLE_COMPRESSION=1 to disable
- * write-side compression entirely. Reads are unaffected — payloads
+ * write-side compression entirely. Reads are unaffected: payloads
  * that were already written compressed remain readable.
  */
 function isCompressionDisabledByEnv() {
@@ -64,7 +65,7 @@ function isCompressionDisabledByEnv() {
 }
 /**
  * Optional codec override (`WORKFLOW_COMPRESSION_CODEC=gzip|zstd`). Lets an
- * operator pin the portable codec (gzip) — useful for A/B comparisons or
+ * operator pin the portable codec (gzip), useful for A/B comparisons or
  * runtimes where zstd read support isn't yet everywhere.
  */
 function codecOverrideFromEnv() {
@@ -77,7 +78,7 @@ function codecOverrideFromEnv() {
     }
 }
 /**
- * Resolve `node:zlib` via `process.getBuiltinModule` — no static import, so
+ * Resolve `node:zlib` via `process.getBuiltinModule`: no static import, so
  * this module stays bundler-safe for browser/edge targets (where it returns
  * undefined and we fall back to gzip).
  */
@@ -106,7 +107,7 @@ function isGzipAvailable() {
  */
 async function pipeThroughTransform(data, transform) {
     const writer = transform.writable.getWriter();
-    // Don't await the write before reading — the transform's internal
+    // Don't await the write before reading: the transform's internal
     // queue can fill up on large payloads, deadlocking writer vs reader.
     const writePromise = writer.write(data).then(() => writer.close());
     // If the transform errors, the reader.read() below rejects first and
@@ -186,8 +187,8 @@ function selectWriteCodec() {
  * @param data - The format-prefixed serialized data (e.g. 'devl' + bytes)
  * @param enabled - Whether the target run supports compressed payloads
  *   (run specVersion >= SPEC_VERSION_SUPPORTS_COMPRESSION, and for
- *   cross-deployment writes, the target deployment's capabilities —
- *   see `getRunCapabilities` in capabilities.ts). zstd and gzip read
+ *   cross-deployment writes, the target deployment's capabilities; see
+ *   `getRunCapabilities` in capabilities.ts). zstd and gzip read
  *   support co-ship, so a single boolean is sufficient.
  * @param stats - Optional telemetry sink; populated when `data` is binary.
  * @returns The compressed data with a codec prefix, or the original data
@@ -257,4 +258,4 @@ export function isCompressed(data) {
     const prefix = peekFormatPrefix(data);
     return (prefix === SerializationFormat.ZSTD || prefix === SerializationFormat.GZIP);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"compression.js","sourceRoot":"","sources":["../../src/serialization/compression.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Composable compression layer for serialized data.\n *\n * Wraps/unwraps serialized payloads with a compression codec, using the\n * format prefix system to mark compressed data (e.g. 'zstd' or 'gzip'\n * wrapping the inner format: 'zstd' + zstd('devl' + payload)).\n *\n * Codec selection (write side): zstd is preferred — it is markedly faster\n * than gzip at a comparable-or-better ratio (see scripts/README.md), and\n * compression runs at every step boundary so the write CPU is a per-step\n * tax. zstd requires `node:zlib` >= 22.15 (Web `CompressionStream` has no\n * zstd), so on a runtime without it we fall back to gzip via the portable\n * `CompressionStream`. `WORKFLOW_COMPRESSION_CODEC=gzip` forces the\n * portable codec.\n *\n * Read side: dispatch on the format prefix, so both 'zstd' and 'gzip'\n * payloads are always decodable regardless of which codec wrote them.\n * (The browser o11y read path decodes zstd via a registered WASM decoder —\n * see `serialization-format.ts`; this module's `decompress` is the Node\n * runtime/replay path and uses `node:zlib`.)\n *\n * Layering order with encryption: compression is applied BEFORE\n * encryption (encr(zstd(devl))) — encrypted bytes are high-entropy and\n * do not compress, so the reverse order would be a no-op.\n *\n * Compression is conditional:\n * - Payloads smaller than {@link COMPRESSION_MIN_BYTES} are passed\n *   through unchanged (codec overhead isn't worth it).\n * - If the compressed result isn't meaningfully smaller than the\n *   original (see {@link COMPRESSION_MIN_SAVINGS_RATIO}), the original\n *   is kept. This protects already-compressed binary payloads (images,\n *   archives, etc.) from wasted CPU and size inflation.\n */\n\nimport {\n  decodeFormatPrefix,\n  encodeWithFormatPrefix,\n  peekFormatPrefix,\n} from './format.js';\nimport { SerializationFormat } from './types.js';\n\n/**\n * Payloads below this size are never compressed. The 4-byte format\n * prefix + codec header/trailer overhead means small payloads gain\n * nothing, and tiny ones would grow.\n */\nexport const COMPRESSION_MIN_BYTES = 1024;\n\n/**\n * Compression must shave off at least this fraction of the payload\n * size to be kept; otherwise the uncompressed original is stored.\n * Guards against incompressible (already-compressed / high-entropy)\n * data paying a permanent decompression tax for a negligible win.\n */\nexport const COMPRESSION_MIN_SAVINGS_RATIO = 0.05;\n\n/** Default zstd compression level — the sweet spot of speed vs ratio. */\nconst ZSTD_LEVEL = 3;\n\n/** Which codec compressed a payload (or `none` when stored uncompressed). */\nexport type CompressionCodec = 'zstd' | 'gzip' | 'none';\n\n/**\n * Escape hatch: set WORKFLOW_DISABLE_COMPRESSION=1 to disable\n * write-side compression entirely. Reads are unaffected — payloads\n * that were already written compressed remain readable.\n */\nfunction isCompressionDisabledByEnv(): boolean {\n  try {\n    return (\n      typeof process !== 'undefined' &&\n      process.env?.WORKFLOW_DISABLE_COMPRESSION === '1'\n    );\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Optional codec override (`WORKFLOW_COMPRESSION_CODEC=gzip|zstd`). Lets an\n * operator pin the portable codec (gzip) — useful for A/B comparisons or\n * runtimes where zstd read support isn't yet everywhere.\n */\nfunction codecOverrideFromEnv(): 'gzip' | 'zstd' | undefined {\n  try {\n    const v = process.env?.WORKFLOW_COMPRESSION_CODEC;\n    return v === 'gzip' || v === 'zstd' ? v : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\ninterface NodeZlib {\n  zstdCompressSync?: (data: Uint8Array, opts?: unknown) => Uint8Array;\n  zstdDecompressSync?: (data: Uint8Array) => Uint8Array;\n  constants?: Record<string, number>;\n}\n\n/**\n * Resolve `node:zlib` via `process.getBuiltinModule` — no static import, so\n * this module stays bundler-safe for browser/edge targets (where it returns\n * undefined and we fall back to gzip).\n */\nfunction getNodeZlib(): NodeZlib | undefined {\n  try {\n    return (\n      globalThis as {\n        process?: { getBuiltinModule?: (id: string) => NodeZlib };\n      }\n    ).process?.getBuiltinModule?.('node:zlib');\n  } catch {\n    return undefined;\n  }\n}\n\nfunction isZstdAvailable(): boolean {\n  const z = getNodeZlib();\n  return (\n    typeof z?.zstdCompressSync === 'function' &&\n    typeof z?.zstdDecompressSync === 'function'\n  );\n}\n\n/**\n * gzip via the web-standard `CompressionStream` (Node 18+, browsers, edge).\n */\nfunction isGzipAvailable(): boolean {\n  return (\n    typeof CompressionStream === 'function' &&\n    typeof DecompressionStream === 'function'\n  );\n}\n\n/**\n * Pipe bytes through a (De)CompressionStream and collect the output.\n */\nasync function pipeThroughTransform(\n  data: Uint8Array,\n  transform: {\n    readable: ReadableStream<Uint8Array>;\n    writable: WritableStream<Uint8Array>;\n  }\n): Promise<Uint8Array> {\n  const writer = transform.writable.getWriter();\n  // Don't await the write before reading — the transform's internal\n  // queue can fill up on large payloads, deadlocking writer vs reader.\n  const writePromise = writer.write(data).then(() => writer.close());\n  // If the transform errors, the reader.read() below rejects first and\n  // propagates; mark the write side as handled so the mirrored rejection\n  // doesn't surface as an unhandled rejection.\n  writePromise.catch(() => {});\n  const chunks: Uint8Array[] = [];\n  let total = 0;\n  const reader = transform.readable.getReader();\n  for (;;) {\n    const { done, value } = await reader.read();\n    if (done) break;\n    chunks.push(value);\n    total += value.length;\n  }\n  await writePromise;\n  const out = new Uint8Array(total);\n  let offset = 0;\n  for (const chunk of chunks) {\n    out.set(chunk, offset);\n    offset += chunk.length;\n  }\n  return out;\n}\n\nasync function gzipBytes(data: Uint8Array): Promise<Uint8Array> {\n  return pipeThroughTransform(data, new CompressionStream('gzip'));\n}\n\nasync function gunzipBytes(data: Uint8Array): Promise<Uint8Array> {\n  return pipeThroughTransform(data, new DecompressionStream('gzip'));\n}\n\nfunction zstdBytes(data: Uint8Array): Uint8Array {\n  const z = getNodeZlib();\n  const level = z?.constants?.ZSTD_c_compressionLevel;\n  const opts =\n    level !== undefined ? { params: { [level]: ZSTD_LEVEL } } : undefined;\n  // biome-ignore lint/style/noNonNullAssertion: guarded by isZstdAvailable()\n  return new Uint8Array(z!.zstdCompressSync!(data, opts));\n}\n\nfunction unzstdBytes(data: Uint8Array): Uint8Array {\n  const z = getNodeZlib();\n  if (!z?.zstdDecompressSync) {\n    throw new Error(\n      'Compressed (zstd) workflow data encountered but node:zlib zstd ' +\n        'support is not available in this runtime (requires Node.js 22.15+). ' +\n        'In the browser, register a zstd decoder via registerZstdDecoder ' +\n        '(serialization-format.ts).'\n    );\n  }\n  return new Uint8Array(z.zstdDecompressSync(data));\n}\n\n/**\n * Telemetry sink describing what the compression layer did to a payload.\n * Populated by {@link compress} (write) and {@link decompress} (read) when\n * a `stats` object is passed. Sizes are measured at the compression\n * boundary — i.e. before encryption is layered on the write side and after\n * decryption on the read side — so they reflect compression's effect, not\n * the at-rest size (which also includes the `encr` envelope and, on some\n * backends, base64 expansion).\n *\n * Field meanings are identical for both directions:\n * - `uncompressedBytes`: the logical (devalue-prefixed) payload size.\n * - `storedBytes`: the size handed to / read from storage (compressed when\n *   a codec applied, otherwise equal to `uncompressedBytes`).\n * - `codec`: which codec applied (`none` when stored uncompressed).\n */\nexport interface CompressionStats {\n  /** True once the compression layer ran (i.e. saw binary data). */\n  recorded?: boolean;\n  /** Whether a codec was applied (write) or present (read). */\n  compressed?: boolean;\n  /** Which codec applied / was present. */\n  codec?: CompressionCodec;\n  /** Logical, uncompressed payload size in bytes. */\n  uncompressedBytes?: number;\n  /** Stored (post-compression) payload size in bytes. */\n  storedBytes?: number;\n}\n\nfunction recordStats(\n  stats: CompressionStats | undefined,\n  codec: CompressionCodec,\n  uncompressedBytes: number,\n  storedBytes: number\n): void {\n  if (!stats) return;\n  stats.recorded = true;\n  stats.compressed = codec !== 'none';\n  stats.codec = codec;\n  stats.uncompressedBytes = uncompressedBytes;\n  stats.storedBytes = storedBytes;\n}\n\n/**\n * Choose the write-side codec given runtime availability and the optional\n * env override. zstd is preferred; gzip is the portable fallback.\n */\nfunction selectWriteCodec(): 'zstd' | 'gzip' | 'none' {\n  const override = codecOverrideFromEnv();\n  if (override === 'gzip') return isGzipAvailable() ? 'gzip' : 'none';\n  // Default and explicit 'zstd' both prefer zstd, then fall back to gzip.\n  if (isZstdAvailable()) return 'zstd';\n  if (isGzipAvailable()) return 'gzip';\n  return 'none';\n}\n\n/**\n * Compress a format-prefixed payload if compression is enabled for the\n * target run and the payload is worth compressing.\n *\n * @param data - The format-prefixed serialized data (e.g. 'devl' + bytes)\n * @param enabled - Whether the target run supports compressed payloads\n *   (run specVersion >= SPEC_VERSION_SUPPORTS_COMPRESSION, and for\n *   cross-deployment writes, the target deployment's capabilities —\n *   see `getRunCapabilities` in capabilities.ts). zstd and gzip read\n *   support co-ship, so a single boolean is sufficient.\n * @param stats - Optional telemetry sink; populated when `data` is binary.\n * @returns The compressed data with a codec prefix, or the original data\n *   when compression is disabled, unavailable, or not worthwhile.\n */\nexport async function compress(\n  data: Uint8Array | unknown,\n  enabled: boolean,\n  stats?: CompressionStats\n): Promise<Uint8Array | unknown> {\n  if (!(data instanceof Uint8Array)) return data;\n  // From here `data` is binary, so every return path records stats.\n  if (\n    !enabled ||\n    data.length < COMPRESSION_MIN_BYTES ||\n    isCompressionDisabledByEnv()\n  ) {\n    recordStats(stats, 'none', data.length, data.length);\n    return data;\n  }\n\n  const codec = selectWriteCodec();\n  if (codec === 'none') {\n    recordStats(stats, 'none', data.length, data.length);\n    return data;\n  }\n\n  const compressed = codec === 'zstd' ? zstdBytes(data) : await gzipBytes(data);\n  const format =\n    codec === 'zstd' ? SerializationFormat.ZSTD : SerializationFormat.GZIP;\n  const wrappedLength = 4 + compressed.length; // format prefix + payload\n  if (wrappedLength >= data.length * (1 - COMPRESSION_MIN_SAVINGS_RATIO)) {\n    recordStats(stats, 'none', data.length, data.length);\n    return data;\n  }\n  recordStats(stats, codec, data.length, wrappedLength);\n  return encodeWithFormatPrefix(format, compressed);\n}\n\n/**\n * Decompress a format-prefixed payload if it's compressed.\n * Dispatches on the prefix ('zstd' or 'gzip') and inflates the inner\n * payload (which carries its own format prefix, e.g. 'devl').\n *\n * Non-compressed data (including non-binary legacy data) is returned\n * unchanged, so this is safe to apply unconditionally on read paths.\n */\nexport async function decompress(\n  data: Uint8Array | unknown,\n  stats?: CompressionStats\n): Promise<Uint8Array | unknown> {\n  if (!(data instanceof Uint8Array)) return data;\n  const prefix = peekFormatPrefix(data);\n\n  if (prefix === SerializationFormat.ZSTD) {\n    const { payload } = decodeFormatPrefix(data);\n    const inflated = unzstdBytes(payload);\n    recordStats(stats, 'zstd', inflated.length, data.length);\n    return inflated;\n  }\n\n  if (prefix === SerializationFormat.GZIP) {\n    if (!isGzipAvailable()) {\n      throw new Error(\n        'Compressed (gzip) workflow data encountered but DecompressionStream ' +\n          'is not available in this runtime. Node.js 18+, browsers, and edge ' +\n          'runtimes all support it.'\n      );\n    }\n    const { payload } = decodeFormatPrefix(data);\n    const inflated = await gunzipBytes(payload);\n    recordStats(stats, 'gzip', inflated.length, data.length);\n    return inflated;\n  }\n\n  recordStats(stats, 'none', data.length, data.length);\n  return data;\n}\n\n/**\n * Check if data is compressed (has a 'zstd' or 'gzip' format prefix).\n */\nexport function isCompressed(data: Uint8Array | unknown): boolean {\n  const prefix = peekFormatPrefix(data);\n  return (\n    prefix === SerializationFormat.ZSTD || prefix === SerializationFormat.GZIP\n  );\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"compression.js","sourceRoot":"","sources":["../../src/serialization/compression.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Composable compression layer for serialized data.\n *\n * Wraps/unwraps serialized payloads with a compression codec, using the\n * format prefix system to mark compressed data (e.g. 'zstd' or 'gzip'\n * wrapping the inner format: 'zstd' + zstd('devl' + payload)).\n *\n * Codec selection (write side): zstd is preferred because it is markedly\n * faster than gzip at a comparable-or-better ratio (see scripts/README.md),\n * and compression runs at every step boundary so the write CPU is a\n * per-step tax. zstd requires `node:zlib` >= 22.15 (Web\n * `CompressionStream` has no zstd), so on a runtime without it we fall back\n * to gzip via the portable\n * `CompressionStream`. `WORKFLOW_COMPRESSION_CODEC=gzip` forces the\n * portable codec.\n *\n * Read side: dispatch on the format prefix, so both 'zstd' and 'gzip'\n * payloads are always decodable regardless of which codec wrote them.\n * (The browser o11y read path decodes zstd via a registered WASM decoder,\n * see `serialization-format.ts`; this module's `decompress` is the Node\n * runtime/replay path and uses `node:zlib`.)\n *\n * Layering order with encryption: compression is applied BEFORE\n * encryption (encr(zstd(devl))): encrypted bytes are high-entropy and\n * do not compress, so the reverse order would be a no-op.\n *\n * Compression is conditional:\n * - Payloads smaller than {@link COMPRESSION_MIN_BYTES} are passed\n *   through unchanged (codec overhead isn't worth it).\n * - If the compressed result isn't meaningfully smaller than the\n *   original (see {@link COMPRESSION_MIN_SAVINGS_RATIO}), the original\n *   is kept. This protects already-compressed binary payloads (images,\n *   archives, etc.) from wasted CPU and size inflation.\n */\n\nimport {\n  decodeFormatPrefix,\n  encodeWithFormatPrefix,\n  peekFormatPrefix,\n} from './format.js';\nimport { SerializationFormat } from './types.js';\n\n/**\n * Payloads below this size are never compressed. The 4-byte format\n * prefix + codec header/trailer overhead means small payloads gain\n * nothing, and tiny ones would grow.\n */\nexport const COMPRESSION_MIN_BYTES = 1024;\n\n/**\n * Compression must shave off at least this fraction of the payload\n * size to be kept; otherwise the uncompressed original is stored.\n * Guards against incompressible (already-compressed / high-entropy)\n * data paying a permanent decompression tax for a negligible win.\n */\nexport const COMPRESSION_MIN_SAVINGS_RATIO = 0.05;\n\n/** Default zstd compression level: the sweet spot of speed vs ratio. */\nconst ZSTD_LEVEL = 3;\n\n/** Which codec compressed a payload (or `none` when stored uncompressed). */\nexport type CompressionCodec = 'zstd' | 'gzip' | 'none';\n\n/**\n * Escape hatch: set WORKFLOW_DISABLE_COMPRESSION=1 to disable\n * write-side compression entirely. Reads are unaffected: payloads\n * that were already written compressed remain readable.\n */\nfunction isCompressionDisabledByEnv(): boolean {\n  try {\n    return (\n      typeof process !== 'undefined' &&\n      process.env?.WORKFLOW_DISABLE_COMPRESSION === '1'\n    );\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Optional codec override (`WORKFLOW_COMPRESSION_CODEC=gzip|zstd`). Lets an\n * operator pin the portable codec (gzip), useful for A/B comparisons or\n * runtimes where zstd read support isn't yet everywhere.\n */\nfunction codecOverrideFromEnv(): 'gzip' | 'zstd' | undefined {\n  try {\n    const v = process.env?.WORKFLOW_COMPRESSION_CODEC;\n    return v === 'gzip' || v === 'zstd' ? v : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\ninterface NodeZlib {\n  zstdCompressSync?: (data: Uint8Array, opts?: unknown) => Uint8Array;\n  zstdDecompressSync?: (data: Uint8Array) => Uint8Array;\n  constants?: Record<string, number>;\n}\n\n/**\n * Resolve `node:zlib` via `process.getBuiltinModule`: no static import, so\n * this module stays bundler-safe for browser/edge targets (where it returns\n * undefined and we fall back to gzip).\n */\nfunction getNodeZlib(): NodeZlib | undefined {\n  try {\n    return (\n      globalThis as {\n        process?: { getBuiltinModule?: (id: string) => NodeZlib };\n      }\n    ).process?.getBuiltinModule?.('node:zlib');\n  } catch {\n    return undefined;\n  }\n}\n\nfunction isZstdAvailable(): boolean {\n  const z = getNodeZlib();\n  return (\n    typeof z?.zstdCompressSync === 'function' &&\n    typeof z?.zstdDecompressSync === 'function'\n  );\n}\n\n/**\n * gzip via the web-standard `CompressionStream` (Node 18+, browsers, edge).\n */\nfunction isGzipAvailable(): boolean {\n  return (\n    typeof CompressionStream === 'function' &&\n    typeof DecompressionStream === 'function'\n  );\n}\n\n/**\n * Pipe bytes through a (De)CompressionStream and collect the output.\n */\nasync function pipeThroughTransform(\n  data: Uint8Array,\n  transform: {\n    readable: ReadableStream<Uint8Array>;\n    writable: WritableStream<Uint8Array>;\n  }\n): Promise<Uint8Array> {\n  const writer = transform.writable.getWriter();\n  // Don't await the write before reading: the transform's internal\n  // queue can fill up on large payloads, deadlocking writer vs reader.\n  const writePromise = writer.write(data).then(() => writer.close());\n  // If the transform errors, the reader.read() below rejects first and\n  // propagates; mark the write side as handled so the mirrored rejection\n  // doesn't surface as an unhandled rejection.\n  writePromise.catch(() => {});\n  const chunks: Uint8Array[] = [];\n  let total = 0;\n  const reader = transform.readable.getReader();\n  for (;;) {\n    const { done, value } = await reader.read();\n    if (done) break;\n    chunks.push(value);\n    total += value.length;\n  }\n  await writePromise;\n  const out = new Uint8Array(total);\n  let offset = 0;\n  for (const chunk of chunks) {\n    out.set(chunk, offset);\n    offset += chunk.length;\n  }\n  return out;\n}\n\nasync function gzipBytes(data: Uint8Array): Promise<Uint8Array> {\n  return pipeThroughTransform(data, new CompressionStream('gzip'));\n}\n\nasync function gunzipBytes(data: Uint8Array): Promise<Uint8Array> {\n  return pipeThroughTransform(data, new DecompressionStream('gzip'));\n}\n\nfunction zstdBytes(data: Uint8Array): Uint8Array {\n  const z = getNodeZlib();\n  const level = z?.constants?.ZSTD_c_compressionLevel;\n  const opts =\n    level !== undefined ? { params: { [level]: ZSTD_LEVEL } } : undefined;\n  // biome-ignore lint/style/noNonNullAssertion: guarded by isZstdAvailable()\n  return new Uint8Array(z!.zstdCompressSync!(data, opts));\n}\n\nfunction unzstdBytes(data: Uint8Array): Uint8Array {\n  const z = getNodeZlib();\n  if (!z?.zstdDecompressSync) {\n    throw new Error(\n      'Compressed (zstd) workflow data encountered but node:zlib zstd ' +\n        'support is not available in this runtime (requires Node.js 22.15+). ' +\n        'In the browser, register a zstd decoder via registerZstdDecoder ' +\n        '(serialization-format.ts).'\n    );\n  }\n  return new Uint8Array(z.zstdDecompressSync(data));\n}\n\n/**\n * Telemetry sink describing what the compression layer did to a payload.\n * Populated by {@link compress} (write) and {@link decompress} (read) when\n * a `stats` object is passed. Sizes are measured at the compression\n * boundary (i.e. before encryption is layered on the write side and after\n * decryption on the read side), so they reflect compression's effect, not\n * the at-rest size (which also includes the `encr` envelope and, on some\n * backends, base64 expansion).\n *\n * Field meanings are identical for both directions:\n * - `uncompressedBytes`: the logical (devalue-prefixed) payload size.\n * - `storedBytes`: the size handed to / read from storage (compressed when\n *   a codec applied, otherwise equal to `uncompressedBytes`).\n * - `codec`: which codec applied (`none` when stored uncompressed).\n */\nexport interface CompressionStats {\n  /** True once the compression layer ran (i.e. saw binary data). */\n  recorded?: boolean;\n  /** Whether a codec was applied (write) or present (read). */\n  compressed?: boolean;\n  /** Which codec applied / was present. */\n  codec?: CompressionCodec;\n  /** Logical, uncompressed payload size in bytes. */\n  uncompressedBytes?: number;\n  /** Stored (post-compression) payload size in bytes. */\n  storedBytes?: number;\n}\n\nfunction recordStats(\n  stats: CompressionStats | undefined,\n  codec: CompressionCodec,\n  uncompressedBytes: number,\n  storedBytes: number\n): void {\n  if (!stats) return;\n  stats.recorded = true;\n  stats.compressed = codec !== 'none';\n  stats.codec = codec;\n  stats.uncompressedBytes = uncompressedBytes;\n  stats.storedBytes = storedBytes;\n}\n\n/**\n * Choose the write-side codec given runtime availability and the optional\n * env override. zstd is preferred; gzip is the portable fallback.\n */\nfunction selectWriteCodec(): 'zstd' | 'gzip' | 'none' {\n  const override = codecOverrideFromEnv();\n  if (override === 'gzip') return isGzipAvailable() ? 'gzip' : 'none';\n  // Default and explicit 'zstd' both prefer zstd, then fall back to gzip.\n  if (isZstdAvailable()) return 'zstd';\n  if (isGzipAvailable()) return 'gzip';\n  return 'none';\n}\n\n/**\n * Compress a format-prefixed payload if compression is enabled for the\n * target run and the payload is worth compressing.\n *\n * @param data - The format-prefixed serialized data (e.g. 'devl' + bytes)\n * @param enabled - Whether the target run supports compressed payloads\n *   (run specVersion >= SPEC_VERSION_SUPPORTS_COMPRESSION, and for\n *   cross-deployment writes, the target deployment's capabilities; see\n *   `getRunCapabilities` in capabilities.ts). zstd and gzip read\n *   support co-ship, so a single boolean is sufficient.\n * @param stats - Optional telemetry sink; populated when `data` is binary.\n * @returns The compressed data with a codec prefix, or the original data\n *   when compression is disabled, unavailable, or not worthwhile.\n */\nexport async function compress(\n  data: Uint8Array | unknown,\n  enabled: boolean,\n  stats?: CompressionStats\n): Promise<Uint8Array | unknown> {\n  if (!(data instanceof Uint8Array)) return data;\n  // From here `data` is binary, so every return path records stats.\n  if (\n    !enabled ||\n    data.length < COMPRESSION_MIN_BYTES ||\n    isCompressionDisabledByEnv()\n  ) {\n    recordStats(stats, 'none', data.length, data.length);\n    return data;\n  }\n\n  const codec = selectWriteCodec();\n  if (codec === 'none') {\n    recordStats(stats, 'none', data.length, data.length);\n    return data;\n  }\n\n  const compressed = codec === 'zstd' ? zstdBytes(data) : await gzipBytes(data);\n  const format =\n    codec === 'zstd' ? SerializationFormat.ZSTD : SerializationFormat.GZIP;\n  const wrappedLength = 4 + compressed.length; // format prefix + payload\n  if (wrappedLength >= data.length * (1 - COMPRESSION_MIN_SAVINGS_RATIO)) {\n    recordStats(stats, 'none', data.length, data.length);\n    return data;\n  }\n  recordStats(stats, codec, data.length, wrappedLength);\n  return encodeWithFormatPrefix(format, compressed);\n}\n\n/**\n * Decompress a format-prefixed payload if it's compressed.\n * Dispatches on the prefix ('zstd' or 'gzip') and inflates the inner\n * payload (which carries its own format prefix, e.g. 'devl').\n *\n * Non-compressed data (including non-binary legacy data) is returned\n * unchanged, so this is safe to apply unconditionally on read paths.\n */\nexport async function decompress(\n  data: Uint8Array | unknown,\n  stats?: CompressionStats\n): Promise<Uint8Array | unknown> {\n  if (!(data instanceof Uint8Array)) return data;\n  const prefix = peekFormatPrefix(data);\n\n  if (prefix === SerializationFormat.ZSTD) {\n    const { payload } = decodeFormatPrefix(data);\n    const inflated = unzstdBytes(payload);\n    recordStats(stats, 'zstd', inflated.length, data.length);\n    return inflated;\n  }\n\n  if (prefix === SerializationFormat.GZIP) {\n    if (!isGzipAvailable()) {\n      throw new Error(\n        'Compressed (gzip) workflow data encountered but DecompressionStream ' +\n          'is not available in this runtime. Node.js 18+, browsers, and edge ' +\n          'runtimes all support it.'\n      );\n    }\n    const { payload } = decodeFormatPrefix(data);\n    const inflated = await gunzipBytes(payload);\n    recordStats(stats, 'gzip', inflated.length, data.length);\n    return inflated;\n  }\n\n  recordStats(stats, 'none', data.length, data.length);\n  return data;\n}\n\n/**\n * Check if data is compressed (has a 'zstd' or 'gzip' format prefix).\n */\nexport function isCompressed(data: Uint8Array | unknown): boolean {\n  const prefix = peekFormatPrefix(data);\n  return (\n    prefix === SerializationFormat.ZSTD || prefix === SerializationFormat.GZIP\n  );\n}\n"]}

package/dist/serialization/encryption.d.ts

@@ -21,7 +21,7 @@ declare const RUN_KEYS_BRAND: unique symbol;
 /**
  * A write-only capability: seal payloads to a run's X25519 public key.
  *
- * This is what a *cross-run* writer holds — a hook resumption targeting
+ * This is what a *cross-run* writer holds: a hook resumption targeting
  * another run, or a child workflow writing into a parent's forwarded stream.
  * It carries no ability to decrypt anything, and because it is a distinct
  * nominal type it cannot be mistaken for symmetric key material.
@@ -47,9 +47,9 @@ export interface SealTarget {
  */
 export interface RunPayloadKeys {
     readonly [RUN_KEYS_BRAND]: true;
-    /** Symmetric AES-256-GCM key — the run's own `encr` payloads. */
+    /** Symmetric AES-256-GCM key: the run's own `encr` payloads. */
     readonly aes: CryptoKey;
-    /** X25519 keypair — opens `encp` payloads sealed to this run. */
+    /** X25519 keypair: opens `encp` payloads sealed to this run. */
     readonly keyPair: RunKeyPair;
     /** Additional authenticated data expected on sealed payloads. */
     readonly aad?: Uint8Array;
@@ -66,7 +66,7 @@ export interface RunPayloadKeys {
  * | ------------------ | ------- | -------------- | ------------------------ |
  * | `CryptoKey`        | `encr`  | `encr`         | same-run (legacy shape)  |
  * | {@link RunPayloadKeys} | `encr`  | `encr`, `encp` | the owning run, o11y     |
- * | {@link SealTarget} | `encp`  | —              | cross-run writers        |
+ * | {@link SealTarget} | `encp`  | (none)         | cross-run writers        |
  *
  * A run's own payloads deliberately stay symmetric even when the writer could
  * seal: sealing costs a fresh ECDH per envelope and 32 extra bytes, and buys
@@ -96,7 +96,7 @@ export declare function sealTo(recipientPublicKey: Uint8Array, aad?: Uint8Array)
  */
 export declare function runPayloadKeys(aes: CryptoKey, keyPair: RunKeyPair, aad?: Uint8Array): RunPayloadKeys;
 /**
- * Build the full key capability for a run from its raw 32-byte key material —
+ * Build the full key capability for a run from its raw 32-byte key material,
  * the value `World.getEncryptionKeyForRun()` returns.
  *
  * Use this anywhere a run reads its own event log: it yields a key that opens
@@ -122,8 +122,8 @@ export declare function resolveEncryptionKey(key: EncryptionKeyParam): Promise<P
  * Encrypt a format-prefixed payload if a key is provided.
  *
  * Wraps the data with the `encr` prefix for symmetric keys, or the `encp`
- * prefix when handed a {@link SealTarget} — a cross-run writer that holds only
- * the recipient's public key.
+ * prefix when handed a {@link SealTarget}, a cross-run writer that holds
+ * only the recipient's public key.
  *
  * @param data - The format-prefixed serialized data
  * @param key - Encryption key (undefined to skip encryption)

package/dist/serialization/encryption.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"encryption.d.ts","sourceRoot":"","sources":["../../src/serialization/encryption.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAGL,KAAK,SAAS,EAEf,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAGL,KAAK,UAAU,EAEhB,MAAM,kBAAkB,CAAC;AAQ1B,YAAY,EAAE,SAAS,EAAE,UAAU,EAAE,CAAC;AAEtC;;;;;;GAMG;AACH,QAAA,MAAM,iBAAiB,eAAkD,CAAC;AAC1E,QAAA,MAAM,cAAc,eAA+C,CAAC;AAEpE;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,CAAC,iBAAiB,CAAC,EAAE,IAAI,CAAC;IACnC,yDAAyD;IACzD,QAAQ,CAAC,kBAAkB,EAAE,UAAU,CAAC;IACxC,8EAA8E;IAC9E,QAAQ,CAAC,GAAG,CAAC,EAAE,UAAU,CAAC;CAC3B;AAED;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,CAAC,cAAc,CAAC,EAAE,IAAI,CAAC;IAChC,iEAAiE;IACjE,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC;IACxB,iEAAiE;IACjE,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC;IAC7B,iEAAiE;IACjE,QAAQ,CAAC,GAAG,CAAC,EAAE,UAAU,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,UAAU,GAAG,cAAc,CAAC;AAEjE;;;;;;;;GAQG;AACH,MAAM,MAAM,aAAa,GAAG,SAAS,GAAG,cAAc,CAAC;AAEvD;;;;;GAKG;AACH,wBAAgB,MAAM,CACpB,kBAAkB,EAAE,UAAU,EAC9B,GAAG,CAAC,EAAE,UAAU,GACf,UAAU,CAEZ;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,GAAG,EAAE,SAAS,EACd,OAAO,EAAE,UAAU,EACnB,GAAG,CAAC,EAAE,UAAU,GACf,cAAc,CAEhB;AAED;;;;;;;;GAQG;AACH,wBAAsB,oBAAoB,CACxC,cAAc,EAAE,UAAU,GACzB,OAAO,CAAC,cAAc,CAAC,CAMzB;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAMhE;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,cAAc,CAMxE;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,UAAU,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,CAK3E;AAED;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAC1B,UAAU,GACV,SAAS,GACT,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,GAC/B,CAAC,MAAM,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAAC,CAAC;AAE5C,wBAAsB,oBAAoB,CACxC,GAAG,EAAE,kBAAkB,GACtB,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAEjC;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,OAAO,CAC3B,IAAI,EAAE,UAAU,GAAG,OAAO,EAC1B,GAAG,EAAE,UAAU,GAAG,SAAS,GAC1B,OAAO,CAAC,UAAU,GAAG,OAAO,CAAC,CAa/B;AAoDD,wBAAsB,OAAO,CAC3B,IAAI,EAAE,UAAU,GAAG,OAAO,EAC1B,GAAG,EAAE,UAAU,GAAG,SAAS,GAC1B,OAAO,CAAC,UAAU,GAAG,OAAO,CAAC,CA0C/B"}
+{"version":3,"file":"encryption.d.ts","sourceRoot":"","sources":["../../src/serialization/encryption.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,EAGL,KAAK,SAAS,EAEf,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAGL,KAAK,UAAU,EAEhB,MAAM,kBAAkB,CAAC;AAQ1B,YAAY,EAAE,SAAS,EAAE,UAAU,EAAE,CAAC;AAEtC;;;;;;GAMG;AACH,QAAA,MAAM,iBAAiB,eAAkD,CAAC;AAC1E,QAAA,MAAM,cAAc,eAA+C,CAAC;AAEpE;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,CAAC,iBAAiB,CAAC,EAAE,IAAI,CAAC;IACnC,yDAAyD;IACzD,QAAQ,CAAC,kBAAkB,EAAE,UAAU,CAAC;IACxC,8EAA8E;IAC9E,QAAQ,CAAC,GAAG,CAAC,EAAE,UAAU,CAAC;CAC3B;AAED;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,CAAC,cAAc,CAAC,EAAE,IAAI,CAAC;IAChC,gEAAgE;IAChE,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC;IACxB,gEAAgE;IAChE,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAC;IAC7B,iEAAiE;IACjE,QAAQ,CAAC,GAAG,CAAC,EAAE,UAAU,CAAC;CAC3B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,UAAU,GAAG,cAAc,CAAC;AAEjE;;;;;;;;GAQG;AACH,MAAM,MAAM,aAAa,GAAG,SAAS,GAAG,cAAc,CAAC;AAEvD;;;;;GAKG;AACH,wBAAgB,MAAM,CACpB,kBAAkB,EAAE,UAAU,EAC9B,GAAG,CAAC,EAAE,UAAU,GACf,UAAU,CAEZ;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,GAAG,EAAE,SAAS,EACd,OAAO,EAAE,UAAU,EACnB,GAAG,CAAC,EAAE,UAAU,GACf,cAAc,CAEhB;AAED;;;;;;;;GAQG;AACH,wBAAsB,oBAAoB,CACxC,cAAc,EAAE,UAAU,GACzB,OAAO,CAAC,cAAc,CAAC,CAMzB;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAMhE;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,cAAc,CAMxE;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,UAAU,GAAG,SAAS,GAAG,SAAS,GAAG,SAAS,CAK3E;AAED;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAC1B,UAAU,GACV,SAAS,GACT,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,GAC/B,CAAC,MAAM,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAAC,CAAC;AAE5C,wBAAsB,oBAAoB,CACxC,GAAG,EAAE,kBAAkB,GACtB,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAEjC;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,OAAO,CAC3B,IAAI,EAAE,UAAU,GAAG,OAAO,EAC1B,GAAG,EAAE,UAAU,GAAG,SAAS,GAC1B,OAAO,CAAC,UAAU,GAAG,OAAO,CAAC,CAa/B;AAoDD,wBAAsB,OAAO,CAC3B,IAAI,EAAE,UAAU,GAAG,OAAO,EAC1B,GAAG,EAAE,UAAU,GAAG,SAAS,GAC1B,OAAO,CAAC,UAAU,GAAG,OAAO,CAAC,CA0C/B"}