@workflow/core 5.0.0-beta.17 → 5.0.0-beta.19

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

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/serialization/client.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C,OAAO,EACL,KAAK,SAAS,EAGf,MAAM,iBAAiB,CAAC;AAKzB;;GAEG;AACH,wBAAsB,SAAS,CAC7B,KAAK,EAAE,OAAO,EACd,aAAa,CAAC,EAAE,SAAS,EACzB,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC,UAAU,GAAG,OAAO,CAAC,CAa/B;AAED;;GAEG;AACH,wBAAsB,WAAW,CAC/B,IAAI,EAAE,UAAU,GAAG,OAAO,EAC1B,aAAa,CAAC,EAAE,SAAS,EACzB,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC,OAAO,CAAC,CAmBlB"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/serialization/client.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAG/C,OAAO,EACL,KAAK,SAAS,EAGf,MAAM,iBAAiB,CAAC;AAKzB;;GAEG;AACH,wBAAsB,SAAS,CAC7B,KAAK,EAAE,OAAO,EACd,aAAa,CAAC,EAAE,SAAS,EACzB,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC,UAAU,GAAG,OAAO,CAAC,CAmB/B;AAED;;GAEG;AACH,wBAAsB,WAAW,CAC/B,IAAI,EAAE,UAAU,GAAG,OAAO,EAC1B,aAAa,CAAC,EAAE,SAAS,EACzB,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC,OAAO,CAAC,CAsBlB"}

package/dist/serialization/client.js

@@ -6,6 +6,7 @@
  */
 import { SerializationError } from '@workflow/errors';
 import { devalueCodec } from './codec-devalue.js';
+import { compress, decompress } from './compression.js';
 import { decrypt as decryptData, encrypt as encryptData, } from './encryption.js';
 import { formatSerializationError, rethrowIfRuntimeError } from './errors.js';
 import { decodeFormatPrefix, encodeWithFormatPrefix } from './format.js';
@@ -17,7 +18,9 @@ export async function serialize(value, encryptionKey, options) {
     try {
         const payload = devalueCodec.serialize(value, 'client', options);
         const prefixed = encodeWithFormatPrefix(SerializationFormat.DEVALUE_V1, payload);
-        return encryptData(prefixed, encryptionKey);
+        // Compress before encrypting — encrypted bytes don't compress.
+        const compressed = await compress(prefixed, options?.compression === true, options?.compressionStats);
+        return encryptData(compressed, encryptionKey);
     }
     catch (error) {
         rethrowIfRuntimeError(error);
@@ -29,7 +32,7 @@ export async function serialize(value, encryptionKey, options) {
  * Deserialize a value for the client environment (e.g. workflow return value).
  */
 export async function deserialize(data, encryptionKey, options) {
-    const decrypted = await decryptData(data, encryptionKey);
+    const decrypted = await decompress(await decryptData(data, encryptionKey), options?.compressionStats);
     if (!(decrypted instanceof Uint8Array)) {
         if (devalueCodec.deserializeLegacy) {
             return devalueCodec.deserializeLegacy(decrypted, 'client', options);
@@ -42,4 +45,4 @@ export async function deserialize(data, encryptionKey, options) {
     }
     throw new Error(`Unsupported serialization format: ${format}`);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/serialization/codec.d.ts

@@ -13,6 +13,7 @@
  * - **json**: Would only support standard JSON types (primitives, arrays,
  *   plain objects). No Date, Map, Set, typed arrays, etc.
  */
+import type { CompressionStats } from './compression.js';
 import type { FormatPrefix } from './types.js';
 /**
  * The serialization mode determines which types are supported and how
@@ -49,6 +50,21 @@ export interface CodecOptions {
      * or other mode-specific type revivers.
      */
     extraRevivers?: Record<string, (value: any) => any>;
+    /**
+     * Whether to gzip-compress the serialized payload (write side only;
+     * reads always handle both compressed and uncompressed data). Must
+     * only be enabled when 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). Defaults to `false`.
+     */
+    compression?: boolean;
+    /**
+     * Optional telemetry sink populated by the compression layer with what
+     * it did to the payload (whether it compressed, logical vs stored size).
+     * Used by the dehydrate/hydrate wrappers to emit OTel span attributes.
+     */
+    compressionStats?: CompressionStats;
 }
 export interface Codec {
     /** The 4-character format prefix identifier (e.g. "devl", "cbor", "json") */

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

@@ -1 +1 @@
-{"version":3,"file":"codec.d.ts","sourceRoot":"","sources":["../../src/serialization/codec.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C;;;;;;;;;;GAUG;AACH,MAAM,MAAM,iBAAiB,GAAG,UAAU,GAAG,MAAM,GAAG,QAAQ,CAAC;AAE/D;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAE7B;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,GAAG,CAAC,CAAC;IAEpD;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,GAAG,CAAC,CAAC;CACrD;AAED,MAAM,WAAW,KAAK;IACpB,6EAA6E;IAC7E,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAC;IAEpC;;;;;;;;;OASG;IACH,SAAS,CACP,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,iBAAiB,EACvB,OAAO,CAAC,EAAE,YAAY,GACrB,UAAU,CAAC;IAEd;;;;;;;;;OASG;IACH,WAAW,CACT,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,iBAAiB,EACvB,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC;IAEX;;;;;;;;;OASG;IACH,iBAAiB,CAAC,CAChB,IAAI,EAAE,OAAO,EACb,IAAI,EAAE,iBAAiB,EACvB,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC;CACZ"}
+{"version":3,"file":"codec.d.ts","sourceRoot":"","sources":["../../src/serialization/codec.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C;;;;;;;;;;GAUG;AACH,MAAM,MAAM,iBAAiB,GAAG,UAAU,GAAG,MAAM,GAAG,QAAQ,CAAC;AAE/D;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAE7B;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,GAAG,CAAC,CAAC;IAEpD;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,GAAG,CAAC,CAAC;IAEpD;;;;;;;OAOG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;CACrC;AAED,MAAM,WAAW,KAAK;IACpB,6EAA6E;IAC7E,QAAQ,CAAC,YAAY,EAAE,YAAY,CAAC;IAEpC;;;;;;;;;OASG;IACH,SAAS,CACP,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,iBAAiB,EACvB,OAAO,CAAC,EAAE,YAAY,GACrB,UAAU,CAAC;IAEd;;;;;;;;;OASG;IACH,WAAW,CACT,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,iBAAiB,EACvB,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC;IAEX;;;;;;;;;OASG;IACH,iBAAiB,CAAC,CAChB,IAAI,EAAE,OAAO,EACb,IAAI,EAAE,iBAAiB,EACvB,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC;CACZ"}

package/dist/serialization/codec.js

@@ -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

@@ -0,0 +1,104 @@
+/**
+ * Composable compression layer for serialized data.
+ *
+ * Wraps/unwraps serialized payloads with a compression codec, using the
+ * 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
+ * `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 —
+ * 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
+ * do not compress, so the reverse order would be a no-op.
+ *
+ * Compression is conditional:
+ * - Payloads smaller than {@link COMPRESSION_MIN_BYTES} are passed
+ *   through unchanged (codec overhead isn't worth it).
+ * - If the compressed result isn't meaningfully smaller than the
+ *   original (see {@link COMPRESSION_MIN_SAVINGS_RATIO}), the original
+ *   is kept. This protects already-compressed binary payloads (images,
+ *   archives, etc.) from wasted CPU and size inflation.
+ */
+/**
+ * Payloads below this size are never compressed. The 4-byte format
+ * prefix + codec header/trailer overhead means small payloads gain
+ * nothing, and tiny ones would grow.
+ */
+export declare const COMPRESSION_MIN_BYTES = 1024;
+/**
+ * Compression must shave off at least this fraction of the payload
+ * size to be kept; otherwise the uncompressed original is stored.
+ * Guards against incompressible (already-compressed / high-entropy)
+ * data paying a permanent decompression tax for a negligible win.
+ */
+export declare const COMPRESSION_MIN_SAVINGS_RATIO = 0.05;
+/** Which codec compressed a payload (or `none` when stored uncompressed). */
+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
+ * the at-rest size (which also includes the `encr` envelope and, on some
+ * backends, base64 expansion).
+ *
+ * Field meanings are identical for both directions:
+ * - `uncompressedBytes`: the logical (devalue-prefixed) payload size.
+ * - `storedBytes`: the size handed to / read from storage (compressed when
+ *   a codec applied, otherwise equal to `uncompressedBytes`).
+ * - `codec`: which codec applied (`none` when stored uncompressed).
+ */
+export interface CompressionStats {
+    /** True once the compression layer ran (i.e. saw binary data). */
+    recorded?: boolean;
+    /** Whether a codec was applied (write) or present (read). */
+    compressed?: boolean;
+    /** Which codec applied / was present. */
+    codec?: CompressionCodec;
+    /** Logical, uncompressed payload size in bytes. */
+    uncompressedBytes?: number;
+    /** Stored (post-compression) payload size in bytes. */
+    storedBytes?: number;
+}
+/**
+ * Compress a format-prefixed payload if compression is enabled for the
+ * target run and the payload is worth compressing.
+ *
+ * @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
+ *   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
+ *   when compression is disabled, unavailable, or not worthwhile.
+ */
+export declare function compress(data: Uint8Array | unknown, enabled: boolean, stats?: CompressionStats): Promise<Uint8Array | unknown>;
+/**
+ * Decompress a format-prefixed payload if it's compressed.
+ * Dispatches on the prefix ('zstd' or 'gzip') and inflates the inner
+ * payload (which carries its own format prefix, e.g. 'devl').
+ *
+ * Non-compressed data (including non-binary legacy data) is returned
+ * unchanged, so this is safe to apply unconditionally on read paths.
+ */
+export declare function decompress(data: Uint8Array | unknown, stats?: CompressionStats): Promise<Uint8Array | unknown>;
+/**
+ * Check if data is compressed (has a 'zstd' or 'gzip' format prefix).
+ */
+export declare function isCompressed(data: Uint8Array | unknown): boolean;
+//# sourceMappingURL=compression.d.ts.map

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

@@ -0,0 +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"}

package/dist/serialization/compression.js

@@ -0,0 +1,260 @@
+/**
+ * Composable compression layer for serialized data.
+ *
+ * Wraps/unwraps serialized payloads with a compression codec, using the
+ * 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
+ * `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 —
+ * 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
+ * do not compress, so the reverse order would be a no-op.
+ *
+ * Compression is conditional:
+ * - Payloads smaller than {@link COMPRESSION_MIN_BYTES} are passed
+ *   through unchanged (codec overhead isn't worth it).
+ * - If the compressed result isn't meaningfully smaller than the
+ *   original (see {@link COMPRESSION_MIN_SAVINGS_RATIO}), the original
+ *   is kept. This protects already-compressed binary payloads (images,
+ *   archives, etc.) from wasted CPU and size inflation.
+ */
+import { decodeFormatPrefix, encodeWithFormatPrefix, peekFormatPrefix, } from './format.js';
+import { SerializationFormat } from './types.js';
+/**
+ * Payloads below this size are never compressed. The 4-byte format
+ * prefix + codec header/trailer overhead means small payloads gain
+ * nothing, and tiny ones would grow.
+ */
+export const COMPRESSION_MIN_BYTES = 1024;
+/**
+ * Compression must shave off at least this fraction of the payload
+ * size to be kept; otherwise the uncompressed original is stored.
+ * Guards against incompressible (already-compressed / high-entropy)
+ * 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. */
+const ZSTD_LEVEL = 3;
+/**
+ * Escape hatch: set WORKFLOW_DISABLE_COMPRESSION=1 to disable
+ * write-side compression entirely. Reads are unaffected — payloads
+ * that were already written compressed remain readable.
+ */
+function isCompressionDisabledByEnv() {
+    try {
+        return (typeof process !== 'undefined' &&
+            process.env?.WORKFLOW_DISABLE_COMPRESSION === '1');
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Optional codec override (`WORKFLOW_COMPRESSION_CODEC=gzip|zstd`). Lets an
+ * operator pin the portable codec (gzip) — useful for A/B comparisons or
+ * runtimes where zstd read support isn't yet everywhere.
+ */
+function codecOverrideFromEnv() {
+    try {
+        const v = process.env?.WORKFLOW_COMPRESSION_CODEC;
+        return v === 'gzip' || v === 'zstd' ? v : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * 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).
+ */
+function getNodeZlib() {
+    try {
+        return globalThis.process?.getBuiltinModule?.('node:zlib');
+    }
+    catch {
+        return undefined;
+    }
+}
+function isZstdAvailable() {
+    const z = getNodeZlib();
+    return (typeof z?.zstdCompressSync === 'function' &&
+        typeof z?.zstdDecompressSync === 'function');
+}
+/**
+ * gzip via the web-standard `CompressionStream` (Node 18+, browsers, edge).
+ */
+function isGzipAvailable() {
+    return (typeof CompressionStream === 'function' &&
+        typeof DecompressionStream === 'function');
+}
+/**
+ * Pipe bytes through a (De)CompressionStream and collect the output.
+ */
+async function pipeThroughTransform(data, transform) {
+    const writer = transform.writable.getWriter();
+    // 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
+    // propagates; mark the write side as handled so the mirrored rejection
+    // doesn't surface as an unhandled rejection.
+    writePromise.catch(() => { });
+    const chunks = [];
+    let total = 0;
+    const reader = transform.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 gzipBytes(data) {
+    return pipeThroughTransform(data, new CompressionStream('gzip'));
+}
+async function gunzipBytes(data) {
+    return pipeThroughTransform(data, new DecompressionStream('gzip'));
+}
+function zstdBytes(data) {
+    const z = getNodeZlib();
+    const level = z?.constants?.ZSTD_c_compressionLevel;
+    const opts = level !== undefined ? { params: { [level]: ZSTD_LEVEL } } : undefined;
+    // biome-ignore lint/style/noNonNullAssertion: guarded by isZstdAvailable()
+    return new Uint8Array(z.zstdCompressSync(data, opts));
+}
+function unzstdBytes(data) {
+    const z = getNodeZlib();
+    if (!z?.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(z.zstdDecompressSync(data));
+}
+function recordStats(stats, codec, uncompressedBytes, storedBytes) {
+    if (!stats)
+        return;
+    stats.recorded = true;
+    stats.compressed = codec !== 'none';
+    stats.codec = codec;
+    stats.uncompressedBytes = uncompressedBytes;
+    stats.storedBytes = storedBytes;
+}
+/**
+ * Choose the write-side codec given runtime availability and the optional
+ * env override. zstd is preferred; gzip is the portable fallback.
+ */
+function selectWriteCodec() {
+    const override = codecOverrideFromEnv();
+    if (override === 'gzip')
+        return isGzipAvailable() ? 'gzip' : 'none';
+    // Default and explicit 'zstd' both prefer zstd, then fall back to gzip.
+    if (isZstdAvailable())
+        return 'zstd';
+    if (isGzipAvailable())
+        return 'gzip';
+    return 'none';
+}
+/**
+ * Compress a format-prefixed payload if compression is enabled for the
+ * target run and the payload is worth compressing.
+ *
+ * @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
+ *   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
+ *   when compression is disabled, unavailable, or not worthwhile.
+ */
+export async function compress(data, enabled, stats) {
+    if (!(data instanceof Uint8Array))
+        return data;
+    // From here `data` is binary, so every return path records stats.
+    if (!enabled ||
+        data.length < COMPRESSION_MIN_BYTES ||
+        isCompressionDisabledByEnv()) {
+        recordStats(stats, 'none', data.length, data.length);
+        return data;
+    }
+    const codec = selectWriteCodec();
+    if (codec === 'none') {
+        recordStats(stats, 'none', data.length, data.length);
+        return data;
+    }
+    const compressed = codec === 'zstd' ? zstdBytes(data) : await gzipBytes(data);
+    const format = codec === 'zstd' ? SerializationFormat.ZSTD : SerializationFormat.GZIP;
+    const wrappedLength = 4 + compressed.length; // format prefix + payload
+    if (wrappedLength >= data.length * (1 - COMPRESSION_MIN_SAVINGS_RATIO)) {
+        recordStats(stats, 'none', data.length, data.length);
+        return data;
+    }
+    recordStats(stats, codec, data.length, wrappedLength);
+    return encodeWithFormatPrefix(format, compressed);
+}
+/**
+ * Decompress a format-prefixed payload if it's compressed.
+ * Dispatches on the prefix ('zstd' or 'gzip') and inflates the inner
+ * payload (which carries its own format prefix, e.g. 'devl').
+ *
+ * Non-compressed data (including non-binary legacy data) is returned
+ * unchanged, so this is safe to apply unconditionally on read paths.
+ */
+export 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;
+}
+/**
+ * Check if data is compressed (has a 'zstd' or 'gzip' format prefix).
+ */
+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"]}

package/dist/serialization/index.d.ts

@@ -4,15 +4,16 @@
  * Re-exports the mode-specific serialize/deserialize functions and
  * the codec/format/encryption abstractions.
  */
-export type { FormatPrefix, SerializableSpecial, Reducers, Revivers, } from './types.js';
-export { SerializationFormat, isFormatPrefix } from './types.js';
 export type { Codec, SerializationMode } from './codec.js';
 export { devalueCodec } from './codec-devalue.js';
-export { encodeWithFormatPrefix, decodeFormatPrefix, peekFormatPrefix, isEncrypted, } from './format.js';
-export { encrypt, decrypt, type CryptoKey, type EncryptionKeyParam, } from './encryption.js';
-import * as workflow from './workflow.js';
-import * as step from './step.js';
+export { COMPRESSION_MIN_BYTES, type CompressionCodec, type CompressionStats, compress, decompress, isCompressed, } from './compression.js';
+export { type CryptoKey, decrypt, type EncryptionKeyParam, encrypt, } from './encryption.js';
+export { decodeFormatPrefix, encodeWithFormatPrefix, isEncrypted, peekFormatPrefix, } from './format.js';
+export type { FormatPrefix, Reducers, Revivers, SerializableSpecial, } from './types.js';
+export { isFormatPrefix, SerializationFormat } from './types.js';
 import * as client from './client.js';
+import * as step from './step.js';
+import * as workflow from './workflow.js';
 export { workflow, step, client };
 export { revive } from './reducers/common.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/serialization/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,YAAY,EACV,YAAY,EACZ,mBAAmB,EACnB,QAAQ,EACR,QAAQ,GACT,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAGjE,YAAY,EAAE,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAC3D,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAGlD,OAAO,EACL,sBAAsB,EACtB,kBAAkB,EAClB,gBAAgB,EAChB,WAAW,GACZ,MAAM,aAAa,CAAC;AAGrB,OAAO,EACL,OAAO,EACP,OAAO,EACP,KAAK,SAAS,EACd,KAAK,kBAAkB,GACxB,MAAM,iBAAiB,CAAC;AAGzB,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAC;AAC1C,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAClC,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC;AACtC,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;AAGlC,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/serialization/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,YAAY,EAAE,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAC3D,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,OAAO,EACL,qBAAqB,EACrB,KAAK,gBAAgB,EACrB,KAAK,gBAAgB,EACrB,QAAQ,EACR,UAAU,EACV,YAAY,GACb,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EACL,KAAK,SAAS,EACd,OAAO,EACP,KAAK,kBAAkB,EACvB,OAAO,GACR,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EACL,kBAAkB,EAClB,sBAAsB,EACtB,WAAW,EACX,gBAAgB,GACjB,MAAM,aAAa,CAAC;AAErB,YAAY,EACV,YAAY,EACZ,QAAQ,EACR,QAAQ,EACR,mBAAmB,GACpB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEjE,OAAO,KAAK,MAAM,MAAM,aAAa,CAAC;AACtC,OAAO,KAAK,IAAI,MAAM,WAAW,CAAC;AAElC,OAAO,KAAK,QAAQ,MAAM,eAAe,CAAC;AAC1C,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;AAGlC,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/serialization/index.js

@@ -4,17 +4,19 @@
  * Re-exports the mode-specific serialize/deserialize functions and
  * the codec/format/encryption abstractions.
  */
-export { SerializationFormat, isFormatPrefix } from './types.js';
 export { devalueCodec } from './codec-devalue.js';
-// Re-export format prefix utilities
-export { encodeWithFormatPrefix, decodeFormatPrefix, peekFormatPrefix, isEncrypted, } from './format.js';
+// Re-export composable compression
+export { COMPRESSION_MIN_BYTES, compress, decompress, isCompressed, } from './compression.js';
 // Re-export composable encryption
-export { encrypt, decrypt, } from './encryption.js';
+export { decrypt, encrypt, } from './encryption.js';
+// Re-export format prefix utilities
+export { decodeFormatPrefix, encodeWithFormatPrefix, isEncrypted, peekFormatPrefix, } from './format.js';
+export { isFormatPrefix, SerializationFormat } from './types.js';
+import * as client from './client.js';
+import * as step from './step.js';
 // Re-export mode-specific modules as namespaces
 import * as workflow from './workflow.js';
-import * as step from './step.js';
-import * as client from './client.js';
 export { workflow, step, client };
 // Re-export revive helper (used by legacy compat in serialization.ts)
 export { revive } from './reducers/common.js';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1 +1 @@
-{"version":3,"file":"step.d.ts","sourceRoot":"","sources":["../../src/serialization/step.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C,OAAO,EACL,KAAK,SAAS,EAGf,MAAM,iBAAiB,CAAC;AAKzB;;GAEG;AACH,wBAAsB,SAAS,CAC7B,KAAK,EAAE,OAAO,EACd,aAAa,CAAC,EAAE,SAAS,EACzB,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC,UAAU,GAAG,OAAO,CAAC,CAa/B;AAED;;GAEG;AACH,wBAAsB,WAAW,CAC/B,IAAI,EAAE,UAAU,GAAG,OAAO,EAC1B,aAAa,CAAC,EAAE,SAAS,EACzB,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC,OAAO,CAAC,CAmBlB"}
+{"version":3,"file":"step.d.ts","sourceRoot":"","sources":["../../src/serialization/step.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAG/C,OAAO,EACL,KAAK,SAAS,EAGf,MAAM,iBAAiB,CAAC;AAKzB;;GAEG;AACH,wBAAsB,SAAS,CAC7B,KAAK,EAAE,OAAO,EACd,aAAa,CAAC,EAAE,SAAS,EACzB,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC,UAAU,GAAG,OAAO,CAAC,CAmB/B;AAED;;GAEG;AACH,wBAAsB,WAAW,CAC/B,IAAI,EAAE,UAAU,GAAG,OAAO,EAC1B,aAAa,CAAC,EAAE,SAAS,EACzB,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC,OAAO,CAAC,CAsBlB"}