@workflow/core 5.0.0-beta.2 → 5.0.0-beta.21

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/encryption.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Composable encryption layer for serialized data.
+ *
+ * Wraps/unwraps serialized payloads with AES-256-GCM encryption,
+ * using the format prefix system to mark encrypted data.
+ */
+import { type CryptoKey } from '../encryption.js';
+export type { CryptoKey };
+/**
+ * Encryption key parameter type. Accepts a resolved key, undefined (no encryption),
+ * a promise, or a resolver that can defer fetching the key until data needs it.
+ */
+export type EncryptionKeyParam = CryptoKey | undefined | Promise<CryptoKey | undefined> | (() => Promise<CryptoKey | undefined>);
+export declare function resolveEncryptionKey(key: EncryptionKeyParam): Promise<CryptoKey | undefined>;
+/**
+ * Encrypt a format-prefixed payload if a key is provided.
+ * Wraps the data with the 'encr' format prefix.
+ *
+ * @param data - The format-prefixed serialized data
+ * @param key - Encryption key (undefined to skip encryption)
+ * @returns The encrypted data with 'encr' prefix, or the original data if no key
+ */
+export declare function encrypt(data: Uint8Array | unknown, key: CryptoKey | undefined): Promise<Uint8Array | unknown>;
+/**
+ * Decrypt a format-prefixed payload if it's encrypted.
+ * Strips the 'encr' format prefix and decrypts the inner payload.
+ *
+ * @param data - The potentially encrypted data
+ * @param key - Encryption key (undefined to skip decryption)
+ * @returns The decrypted inner payload, or the original data if not encrypted
+ */
+export declare function decrypt(data: Uint8Array | unknown, key: CryptoKey | undefined): Promise<Uint8Array | unknown>;
+//# sourceMappingURL=encryption.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"encryption.d.ts","sourceRoot":"","sources":["../../src/serialization/encryption.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,EAGL,KAAK,SAAS,EACf,MAAM,kBAAkB,CAAC;AAQ1B,YAAY,EAAE,SAAS,EAAE,CAAC;AAE1B;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAC1B,SAAS,GACT,SAAS,GACT,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC,GAC9B,CAAC,MAAM,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC,CAAC,CAAC;AAE3C,wBAAsB,oBAAoB,CACxC,GAAG,EAAE,kBAAkB,GACtB,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC,CAEhC;AAED;;;;;;;GAOG;AACH,wBAAsB,OAAO,CAC3B,IAAI,EAAE,UAAU,GAAG,OAAO,EAC1B,GAAG,EAAE,SAAS,GAAG,SAAS,GACzB,OAAO,CAAC,UAAU,GAAG,OAAO,CAAC,CAI/B;AAED;;;;;;;GAOG;AACH,wBAAsB,OAAO,CAC3B,IAAI,EAAE,UAAU,GAAG,OAAO,EAC1B,GAAG,EAAE,SAAS,GAAG,SAAS,GACzB,OAAO,CAAC,UAAU,GAAG,OAAO,CAAC,CAqC/B"}

package/dist/serialization/encryption.js

@@ -0,0 +1,70 @@
+/**
+ * Composable encryption layer for serialized data.
+ *
+ * Wraps/unwraps serialized payloads with AES-256-GCM encryption,
+ * using the format prefix system to mark encrypted data.
+ */
+import { RuntimeDecryptionError } from '@workflow/errors';
+import { decrypt as aesGcmDecrypt, encrypt as aesGcmEncrypt, } from '../encryption.js';
+import { decodeFormatPrefix, encodeWithFormatPrefix, peekFormatPrefix, } from './format.js';
+import { SerializationFormat } from './types.js';
+export async function resolveEncryptionKey(key) {
+    return typeof key === 'function' ? key() : key;
+}
+/**
+ * Encrypt a format-prefixed payload if a key is provided.
+ * Wraps the data with the 'encr' format prefix.
+ *
+ * @param data - The format-prefixed serialized data
+ * @param key - Encryption key (undefined to skip encryption)
+ * @returns The encrypted data with 'encr' prefix, or the original data if no key
+ */
+export async function encrypt(data, key) {
+    if (!key || !(data instanceof Uint8Array))
+        return data;
+    const encrypted = await aesGcmEncrypt(key, data);
+    return encodeWithFormatPrefix(SerializationFormat.ENCRYPTED, encrypted);
+}
+/**
+ * Decrypt a format-prefixed payload if it's encrypted.
+ * Strips the 'encr' format prefix and decrypts the inner payload.
+ *
+ * @param data - The potentially encrypted data
+ * @param key - Encryption key (undefined to skip decryption)
+ * @returns The decrypted inner payload, or the original data if not encrypted
+ */
+export async function decrypt(data, key) {
+    // Non-binary data is returned as-is.
+    if (!(data instanceof Uint8Array))
+        return data;
+    const format = peekFormatPrefix(data);
+    // If the data is encrypted but no key was provided, fail fast.
+    if (format === SerializationFormat.ENCRYPTED && !key) {
+        throw new RuntimeDecryptionError('Encrypted data encountered but no encryption key is available. ' +
+            'Encryption is not configured or no key was provided for this run.', {
+            context: {
+                operation: 'decrypt',
+                byteLength: data.byteLength,
+                formatPrefix: 'encr',
+            },
+        });
+    }
+    // If the data is not encrypted, return it unchanged.
+    if (format !== SerializationFormat.ENCRYPTED)
+        return data;
+    const { payload } = decodeFormatPrefix(data);
+    try {
+        return await aesGcmDecrypt(key, payload);
+    }
+    catch (error) {
+        // The low-level AES layer only sees the stripped payload, so it cannot
+        // record the outer envelope prefix. This layer peeked it (`encr`), so
+        // enrich the diagnostic context with the real format prefix before
+        // rethrowing.
+        if (RuntimeDecryptionError.is(error) && error.context) {
+            error.context.formatPrefix = format;
+        }
+        throw error;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/serialization/errors.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Shared error formatting utility for serialization failures.
+ *
+ * Used by the mode-specific serializers (workflow, step, client) to
+ * produce consistent error messages with devalue path information.
+ *
+ * Returns a `{ message, hint }` pair so callers can throw a
+ * `SerializationError(message, { hint, cause })` and have the hint flow
+ * through the standard friendly-errors framing instead of being baked
+ * into the message string.
+ */
+/**
+ * Rethrow SDK runtime errors that must not be reframed as
+ * `SerializationError`.
+ *
+ * The serialize/dehydrate wrappers catch every throw and reframe it as a
+ * `SerializationError` (which classifies as `USER_ERROR`). That's correct
+ * for genuine serialization failures, but a `RuntimeDecryptionError` from
+ * the AES-GCM layer is an SDK-internal failure that must keep its identity
+ * so the run-failure classifier routes it to `RUNTIME_ERROR`. Call this at
+ * the top of each serialize catch block to let those errors propagate
+ * unchanged.
+ */
+export declare function rethrowIfRuntimeError(error: unknown): void;
+/**
+ * Format a serialization error with context about what failed.
+ * Extracts path, value, and reason from devalue's DevalueError when available.
+ * Logs the problematic value to the console for better debugging.
+ */
+export declare function formatSerializationError(context: string, error: unknown): {
+    message: string;
+    hint: string;
+};
+//# sourceMappingURL=errors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/serialization/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAMH;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAI1D;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,OAAO,GACb;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAqBnC"}

package/dist/serialization/errors.js

@@ -0,0 +1,59 @@
+/**
+ * Shared error formatting utility for serialization failures.
+ *
+ * Used by the mode-specific serializers (workflow, step, client) to
+ * produce consistent error messages with devalue path information.
+ *
+ * Returns a `{ message, hint }` pair so callers can throw a
+ * `SerializationError(message, { hint, cause })` and have the hint flow
+ * through the standard friendly-errors framing instead of being baked
+ * into the message string.
+ */
+import { RuntimeDecryptionError } from '@workflow/errors';
+import { DevalueError } from 'devalue';
+import { runtimeLogger } from '../logger.js';
+/**
+ * Rethrow SDK runtime errors that must not be reframed as
+ * `SerializationError`.
+ *
+ * The serialize/dehydrate wrappers catch every throw and reframe it as a
+ * `SerializationError` (which classifies as `USER_ERROR`). That's correct
+ * for genuine serialization failures, but a `RuntimeDecryptionError` from
+ * the AES-GCM layer is an SDK-internal failure that must keep its identity
+ * so the run-failure classifier routes it to `RUNTIME_ERROR`. Call this at
+ * the top of each serialize catch block to let those errors propagate
+ * unchanged.
+ */
+export function rethrowIfRuntimeError(error) {
+    if (RuntimeDecryptionError.is(error)) {
+        throw error;
+    }
+}
+/**
+ * Format a serialization error with context about what failed.
+ * Extracts path, value, and reason from devalue's DevalueError when available.
+ * Logs the problematic value to the console for better debugging.
+ */
+export function formatSerializationError(context, error) {
+    // `returning` for outputs, `passing` for everything that crosses the
+    // boundary the other way (arguments, stream messages, etc.).
+    const verb = context.includes('return value') ? 'returning' : 'passing';
+    let message = `Failed to serialize ${context}`;
+    if (error instanceof DevalueError && error.path) {
+        message += ` at path "${error.path}"`;
+    }
+    // Workflow can serialize a much richer set than the devalue defaults —
+    // classes registered via `WORKFLOW_SERIALIZE`, FatalError / RetryableError
+    // subclasses, AbortSignal, etc. Pointing at the foundations doc keeps
+    // this hint accurate as the supported set grows, instead of repeating
+    // a hardcoded list that drifts out of sync.
+    const hint = `Ensure you're ${verb} workflow serializable types. Check the serialization docs to see what's serializable: https://workflow-sdk.dev/docs/foundations/serialization`;
+    if (error instanceof DevalueError && error.value !== undefined) {
+        runtimeLogger.error('Serialization failed', {
+            context,
+            problematicValue: error.value,
+        });
+    }
+    return { message, hint };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/serialization/format.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Format prefix system for serialized payloads.
+ *
+ * All serialized payloads are prefixed with a 4-byte format identifier that
+ * allows the deserializer to determine how to decode the payload. This enables:
+ *
+ * 1. Self-describing payloads — the World layer is agnostic to serialization format
+ * 2. Gradual migration — old runs keep working, new runs can use new formats
+ * 3. Composability — encryption can wrap any format ("encr" wrapping "devl")
+ * 4. Debugging — raw data inspection immediately reveals the format
+ *
+ * Format: [4 bytes: format identifier][payload]
+ *
+ * The format prefix is open-ended — any 4-character [a-z0-9] string is valid.
+ * This allows new codecs to be added without modifying this module.
+ */
+import { type FormatPrefix } from './types.js';
+/**
+ * Encode a payload with a format prefix.
+ *
+ * @param format - The format identifier (4 chars, [a-z0-9])
+ * @param payload - The serialized payload bytes
+ * @returns A new Uint8Array with format prefix prepended
+ */
+export declare function encodeWithFormatPrefix(format: FormatPrefix, payload: Uint8Array | unknown): Uint8Array | unknown;
+/**
+ * Peek at the format prefix without consuming it.
+ *
+ * Returns the prefix if it's a valid format prefix ([a-z0-9]{4}),
+ * or null if the data is legacy/non-binary or doesn't start with a
+ * valid prefix.
+ *
+ * @param data - The format-prefixed data
+ * @returns The format prefix, or null
+ */
+export declare function peekFormatPrefix(data: Uint8Array | unknown): FormatPrefix | null;
+/**
+ * Check if data is encrypted (has 'encr' format prefix).
+ */
+export declare function isEncrypted(data: Uint8Array | unknown): boolean;
+/**
+ * Decode a format-prefixed payload.
+ *
+ * Unlike the legacy implementation which only accepted known formats
+ * (`devl`, `encr`), this function accepts any valid format prefix
+ * (`[a-z0-9]{4}`). This is intentional for forward compatibility —
+ * new codecs (e.g. `cbor`) can be added without modifying this module.
+ * Callers are responsible for checking whether they support the returned
+ * format and throwing an appropriate error if not (e.g. "Unsupported
+ * serialization format").
+ *
+ * @param data - The format-prefixed data
+ * @returns An object with the format prefix and payload
+ * @throws Error if the data is too short or has an invalid prefix
+ */
+export declare function decodeFormatPrefix(data: Uint8Array | unknown): {
+    format: FormatPrefix;
+    payload: Uint8Array;
+};
+//# sourceMappingURL=format.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../src/serialization/format.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EACL,KAAK,YAAY,EAGlB,MAAM,YAAY,CAAC;AAQpB;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,UAAU,GAAG,OAAO,GAC5B,UAAU,GAAG,OAAO,CAUtB;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,UAAU,GAAG,OAAO,GACzB,YAAY,GAAG,IAAI,CAOrB;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,GAAG,OAAO,CAE/D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,GAAG;IAC9D,MAAM,EAAE,YAAY,CAAC;IACrB,OAAO,EAAE,UAAU,CAAC;CACrB,CA0BA"}