@workflow/core 5.0.0-beta.5 → 5.0.0-beta.51

package/dist/serialization/client.d.ts

@@ -5,13 +5,13 @@
  * arguments) and when receiving workflow return values. Supports encryption.
  */
 import type { CodecOptions } from './codec.js';
-import { type CryptoKey } from './encryption.js';
+import { type PayloadKey } from './encryption.js';
 /**
  * Serialize a value from the client environment (e.g. workflow arguments).
  */
-export declare function serialize(value: unknown, encryptionKey?: CryptoKey, options?: CodecOptions): Promise<Uint8Array | unknown>;
+export declare function serialize(value: unknown, encryptionKey?: PayloadKey, options?: CodecOptions): Promise<Uint8Array | unknown>;
 /**
  * Deserialize a value for the client environment (e.g. workflow return value).
  */
-export declare function deserialize(data: Uint8Array | unknown, encryptionKey?: CryptoKey, options?: CodecOptions): Promise<unknown>;
+export declare function deserialize(data: Uint8Array | unknown, encryptionKey?: PayloadKey, options?: CodecOptions): Promise<unknown>;
 //# sourceMappingURL=client.d.ts.map

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,CAY/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,EAGL,KAAK,UAAU,EAChB,MAAM,iBAAiB,CAAC;AAKzB;;GAEG;AACH,wBAAsB,SAAS,CAC7B,KAAK,EAAE,OAAO,EACd,aAAa,CAAC,EAAE,UAAU,EAC1B,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,UAAU,EAC1B,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAAC,OAAO,CAAC,CAsBlB"}

package/dist/serialization/client.js

@@ -6,8 +6,9 @@
  */
 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 } from './errors.js';
+import { formatSerializationError, rethrowIfRuntimeError } from './errors.js';
 import { decodeFormatPrefix, encodeWithFormatPrefix } from './format.js';
 import { SerializationFormat } from './types.js';
 /**
@@ -17,9 +18,12 @@ 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, since encrypted bytes don't compress.
+        const compressed = await compress(prefixed, options?.compression === true, options?.compressionStats);
+        return encryptData(compressed, encryptionKey);
     }
     catch (error) {
+        rethrowIfRuntimeError(error);
         const { message, hint } = formatSerializationError('client value', error);
         throw new SerializationError(message, { hint, cause: error });
     }
@@ -28,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);
@@ -41,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-devalue-vm.d.ts

@@ -0,0 +1,16 @@
+/**
+ * VM-compatible devalue codec.
+ *
+ * Same as codec-devalue.ts but uses VM-compatible reducers/revivers
+ * (no Node.js Buffer, no node:util). Safe to bundle into the QuickJS VM.
+ */
+import type { Codec } from './codec.js';
+/**
+ * The workflow-mode reducer/reviver key sets, exported for the QuickJS
+ * host serde's exhaustiveness test (quickjs-serde.test.ts), which pins
+ * that the handle-space codec implements exactly these.
+ */
+export declare function getWorkflowModeReducerKeys(): string[];
+export declare function getWorkflowModeReviverKeys(): string[];
+export declare const devalueVmCodec: Codec;
+//# sourceMappingURL=codec-devalue-vm.d.ts.map

package/dist/serialization/codec-devalue-vm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codec-devalue-vm.d.ts","sourceRoot":"","sources":["../../src/serialization/codec-devalue-vm.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,KAAK,EAAqB,MAAM,YAAY,CAAC;AAyI3D;;;;GAIG;AACH,wBAAgB,0BAA0B,IAAI,MAAM,EAAE,CAErD;AACD,wBAAgB,0BAA0B,IAAI,MAAM,EAAE,CAErD;AAED,eAAO,MAAM,cAAc,EAAE,KAyB5B,CAAC"}

package/dist/serialization/codec-devalue-vm.js

@@ -0,0 +1,148 @@
+/**
+ * VM-compatible devalue codec.
+ *
+ * Same as codec-devalue.ts but uses VM-compatible reducers/revivers
+ * (no Node.js Buffer, no node:util). Safe to bundle into the QuickJS VM.
+ */
+import { parse, stringify, unflatten } from 'devalue';
+import { getClassReducers, getClassRevivers } from './reducers/class-vm.js';
+import { getCommonReducers, getCommonRevivers } from './reducers/common-vm.js';
+import { getStepFunctionReducer, getStepFunctionReviver, } from './reducers/step-function-vm.js';
+import { SerializationFormat } from './types.js';
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+// ---- AbortController / AbortSignal (workflow VM context) ----
+// Mirrors the node:vm engine's workflow-context abort reducers/revivers in
+// serialization.ts: reduce by reading the stream/hook symbols stamped at
+// controller construction; revive to the bootstrap's WorkflowAbortSignal
+// class (looked up lazily on globalThis, since the serde bundle is
+// evaluated before the bootstrap defines it).
+const ABORT_STREAM_NAME = Symbol.for('WORKFLOW_ABORT_STREAM_NAME');
+const ABORT_HOOK_TOKEN = Symbol.for('WORKFLOW_ABORT_HOOK_TOKEN');
+function reduceAbortBySymbol(signal, holder) {
+    const streamName = holder[ABORT_STREAM_NAME] ?? holder.signal?.[ABORT_STREAM_NAME];
+    const hookToken = holder[ABORT_HOOK_TOKEN] ?? holder.signal?.[ABORT_HOOK_TOKEN];
+    if (!streamName) {
+        throw new Error('AbortController/AbortSignal stream name is not set');
+    }
+    return {
+        streamName,
+        hookToken,
+        aborted: signal.aborted,
+        reason: signal.aborted ? signal.reason : undefined,
+    };
+}
+function reviveAbortSignalVM(value) {
+    const Cls = globalThis.__WorkflowAbortSignal;
+    if (typeof Cls !== 'function') {
+        throw new Error('WorkflowAbortSignal is not registered in the VM (bootstrap not evaluated)');
+    }
+    const signal = new Cls(value.streamName, value.hookToken);
+    if (value.aborted)
+        signal._setAborted(value.reason);
+    return signal;
+}
+function getAbortReducersVM() {
+    return {
+        AbortController: (value) => {
+            if (!value || typeof value !== 'object' || !value.signal)
+                return false;
+            const hasAbortSymbol = value[ABORT_STREAM_NAME] ?? value.signal?.[ABORT_STREAM_NAME];
+            if (hasAbortSymbol === undefined)
+                return false;
+            return reduceAbortBySymbol(value.signal, value);
+        },
+        AbortSignal: (value) => {
+            if (!value || typeof value !== 'object')
+                return false;
+            if (value[ABORT_STREAM_NAME] === undefined)
+                return false;
+            return reduceAbortBySymbol(value, value);
+        },
+    };
+}
+function getAbortReviversVM() {
+    return {
+        AbortController: (value) => ({
+            [ABORT_STREAM_NAME]: value.streamName,
+            [ABORT_HOOK_TOKEN]: value.hookToken,
+            signal: reviveAbortSignalVM(value),
+            abort: () => { },
+        }),
+        AbortSignal: (value) => reviveAbortSignalVM(value),
+    };
+}
+function getReducersForMode(mode) {
+    switch (mode) {
+        case 'workflow':
+            return {
+                ...getAbortReducersVM(),
+                ...getClassReducers(),
+                ...getStepFunctionReducer(),
+                ...getCommonReducers(),
+            };
+        case 'step':
+            return {
+                ...getClassReducers(),
+                ...getCommonReducers(),
+            };
+        case 'client':
+            return {
+                ...getClassReducers(),
+                ...getCommonReducers(),
+            };
+    }
+}
+function getReviversForMode(mode) {
+    switch (mode) {
+        case 'workflow':
+            return {
+                ...getAbortReviversVM(),
+                ...getClassRevivers(),
+                ...getStepFunctionReviver(),
+                ...getCommonRevivers(),
+            };
+        case 'step':
+            return {
+                ...getClassRevivers(),
+                ...getCommonRevivers(),
+            };
+        case 'client':
+            return {
+                ...getClassRevivers(),
+                ...getCommonRevivers(),
+                StepFunction: () => {
+                    throw new Error('Step functions cannot be deserialized in client context.');
+                },
+            };
+    }
+}
+/**
+ * The workflow-mode reducer/reviver key sets, exported for the QuickJS
+ * host serde's exhaustiveness test (quickjs-serde.test.ts), which pins
+ * that the handle-space codec implements exactly these.
+ */
+export function getWorkflowModeReducerKeys() {
+    return Object.keys(getReducersForMode('workflow'));
+}
+export function getWorkflowModeReviverKeys() {
+    return Object.keys(getReviversForMode('workflow'));
+}
+export const devalueVmCodec = {
+    formatPrefix: SerializationFormat.DEVALUE_V1,
+    serialize(value, mode) {
+        const reducers = getReducersForMode(mode);
+        const str = stringify(value, reducers);
+        return encoder.encode(str);
+    },
+    deserialize(data, mode) {
+        const revivers = getReviversForMode(mode);
+        const str = decoder.decode(data);
+        return parse(str, revivers);
+    },
+    deserializeLegacy(data, mode) {
+        const revivers = getReviversForMode(mode);
+        return unflatten(data, revivers);
+    },
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"codec-devalue-vm.js","sourceRoot":"","sources":["../../src/serialization/codec-devalue-vm.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * VM-compatible devalue codec.\n *\n * Same as codec-devalue.ts but uses VM-compatible reducers/revivers\n * (no Node.js Buffer, no node:util). Safe to bundle into the QuickJS VM.\n */\n\nimport { parse, stringify, unflatten } from 'devalue';\nimport type { Codec, SerializationMode } from './codec.js';\nimport { getClassReducers, getClassRevivers } from './reducers/class-vm.js';\nimport { getCommonReducers, getCommonRevivers } from './reducers/common-vm.js';\nimport {\n  getStepFunctionReducer,\n  getStepFunctionReviver,\n} from './reducers/step-function-vm.js';\nimport { type Reducers, type Revivers, SerializationFormat } from './types.js';\n\nconst encoder = new TextEncoder();\nconst decoder = new TextDecoder();\n\n// ---- AbortController / AbortSignal (workflow VM context) ----\n// Mirrors the node:vm engine's workflow-context abort reducers/revivers in\n// serialization.ts: reduce by reading the stream/hook symbols stamped at\n// controller construction; revive to the bootstrap's WorkflowAbortSignal\n// class (looked up lazily on globalThis, since the serde bundle is\n// evaluated before the bootstrap defines it).\nconst ABORT_STREAM_NAME = Symbol.for('WORKFLOW_ABORT_STREAM_NAME');\nconst ABORT_HOOK_TOKEN = Symbol.for('WORKFLOW_ABORT_HOOK_TOKEN');\n\ntype AbortSerialized = {\n  streamName: string;\n  hookToken: string;\n  aborted: boolean;\n  reason?: unknown;\n};\n\nfunction reduceAbortBySymbol(\n  signal: { aborted: boolean; reason?: unknown },\n  holder: any\n): AbortSerialized {\n  const streamName =\n    holder[ABORT_STREAM_NAME] ?? holder.signal?.[ABORT_STREAM_NAME];\n  const hookToken =\n    holder[ABORT_HOOK_TOKEN] ?? holder.signal?.[ABORT_HOOK_TOKEN];\n  if (!streamName) {\n    throw new Error('AbortController/AbortSignal stream name is not set');\n  }\n  return {\n    streamName,\n    hookToken,\n    aborted: signal.aborted,\n    reason: signal.aborted ? signal.reason : undefined,\n  };\n}\n\nfunction reviveAbortSignalVM(value: AbortSerialized) {\n  const Cls = (globalThis as any).__WorkflowAbortSignal;\n  if (typeof Cls !== 'function') {\n    throw new Error(\n      'WorkflowAbortSignal is not registered in the VM (bootstrap not evaluated)'\n    );\n  }\n  const signal = new Cls(value.streamName, value.hookToken);\n  if (value.aborted) signal._setAborted(value.reason);\n  return signal;\n}\n\nfunction getAbortReducersVM(): Partial<Reducers> {\n  return {\n    AbortController: (value) => {\n      if (!value || typeof value !== 'object' || !value.signal) return false;\n      const hasAbortSymbol =\n        value[ABORT_STREAM_NAME] ?? value.signal?.[ABORT_STREAM_NAME];\n      if (hasAbortSymbol === undefined) return false;\n      return reduceAbortBySymbol(value.signal, value);\n    },\n    AbortSignal: (value) => {\n      if (!value || typeof value !== 'object') return false;\n      if ((value as any)[ABORT_STREAM_NAME] === undefined) return false;\n      return reduceAbortBySymbol(value as any, value);\n    },\n  };\n}\n\nfunction getAbortReviversVM(): Partial<Revivers> {\n  return {\n    AbortController: (value: AbortSerialized) => ({\n      [ABORT_STREAM_NAME]: value.streamName,\n      [ABORT_HOOK_TOKEN]: value.hookToken,\n      signal: reviveAbortSignalVM(value),\n      abort: () => {},\n    }),\n    AbortSignal: (value: AbortSerialized) => reviveAbortSignalVM(value),\n  };\n}\n\nfunction getReducersForMode(mode: SerializationMode): Partial<Reducers> {\n  switch (mode) {\n    case 'workflow':\n      return {\n        ...getAbortReducersVM(),\n        ...getClassReducers(),\n        ...getStepFunctionReducer(),\n        ...getCommonReducers(),\n      };\n    case 'step':\n      return {\n        ...getClassReducers(),\n        ...getCommonReducers(),\n      };\n    case 'client':\n      return {\n        ...getClassReducers(),\n        ...getCommonReducers(),\n      };\n  }\n}\n\nfunction getReviversForMode(mode: SerializationMode): Partial<Revivers> {\n  switch (mode) {\n    case 'workflow':\n      return {\n        ...getAbortReviversVM(),\n        ...getClassRevivers(),\n        ...getStepFunctionReviver(),\n        ...getCommonRevivers(),\n      };\n    case 'step':\n      return {\n        ...getClassRevivers(),\n        ...getCommonRevivers(),\n      };\n    case 'client':\n      return {\n        ...getClassRevivers(),\n        ...getCommonRevivers(),\n        StepFunction: () => {\n          throw new Error(\n            'Step functions cannot be deserialized in client context.'\n          );\n        },\n      };\n  }\n}\n\n/**\n * The workflow-mode reducer/reviver key sets, exported for the QuickJS\n * host serde's exhaustiveness test (quickjs-serde.test.ts), which pins\n * that the handle-space codec implements exactly these.\n */\nexport function getWorkflowModeReducerKeys(): string[] {\n  return Object.keys(getReducersForMode('workflow'));\n}\nexport function getWorkflowModeReviverKeys(): string[] {\n  return Object.keys(getReviversForMode('workflow'));\n}\n\nexport const devalueVmCodec: Codec = {\n  formatPrefix: SerializationFormat.DEVALUE_V1,\n\n  serialize(value: unknown, mode: SerializationMode): Uint8Array {\n    const reducers = getReducersForMode(mode);\n    const str = stringify(\n      value,\n      reducers as Record<string, (value: any) => any>\n    );\n    return encoder.encode(str);\n  },\n\n  deserialize(data: Uint8Array, mode: SerializationMode): unknown {\n    const revivers = getReviversForMode(mode);\n    const str = decoder.decode(data);\n    return parse(str, revivers as Record<string, (value: any) => any>);\n  },\n\n  deserializeLegacy(data: unknown, mode: SerializationMode): unknown {\n    const revivers = getReviversForMode(mode);\n    return unflatten(\n      data as any[],\n      revivers as Record<string, (value: any) => any>\n    );\n  },\n};\n"]}

package/dist/serialization/codec-devalue.d.ts

@@ -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).
  */

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

@@ -1 +1 @@
-{"version":3,"file":"codec-devalue.d.ts","sourceRoot":"","sources":["../../src/serialization/codec-devalue.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EAAE,KAAK,EAAmC,MAAM,YAAY,CAAC;AAwFzE,eAAO,MAAM,YAAY,EAAE,KA2C1B,CAAC"}
+{"version":3,"file":"codec-devalue.d.ts","sourceRoot":"","sources":["../../src/serialization/codec-devalue.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AASH,OAAO,KAAK,EAAE,KAAK,EAAmC,MAAM,YAAY,CAAC;AAuGzE,eAAO,MAAM,YAAY,EAAE,KAmD1B,CAAC"}

package/dist/serialization/codec-devalue.js

@@ -5,17 +5,29 @@
  * 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).
  */
-import { parse, stringify, unflatten } from 'devalue';
+import { defaultParseOperations, parse, stringify, unflatten, } from 'devalue';
+import { hardenedStringifyOperations, withGuestCodeStats } from './hardened.js';
 import { getClassReducers, getClassRevivers } from './reducers/class.js';
 import { getCommonReducers, getCommonRevivers } from './reducers/common.js';
 import { getStepFunctionReducer, getStepFunctionReviver, } from './reducers/step-function.js';
 import { SerializationFormat } from './types.js';
 const encoder = new TextEncoder();
 const decoder = new TextDecoder();
+const MAX_SPARSE_ARRAY_LENGTH = 100_000;
+const parseOptions = {
+    operations: {
+        createSparseArray(length) {
+            if (length > MAX_SPARSE_ARRAY_LENGTH) {
+                throw new RangeError(`Sparse array length ${length} exceeds the maximum of ${MAX_SPARSE_ARRAY_LENGTH}`);
+            }
+            return defaultParseOperations.createSparseArray(length);
+        },
+    },
+};
 // ---- Reducer/Reviver composition per mode ----
 function getReducersForMode(mode, global = globalThis, extraReducers) {
     let base;
@@ -82,17 +94,23 @@ export const devalueCodec = {
     formatPrefix: SerializationFormat.DEVALUE_V1,
     serialize(value, mode, options) {
         const reducers = getReducersForMode(mode, options?.global, options?.extraReducers);
-        const str = stringify(value, reducers);
+        // Hardened operations: devalue's own introspection (classification,
+        // built-in extraction, property reads) goes through captured host
+        // intrinsics and descriptor reads, so serializing a value constructed
+        // inside a workflow VM cannot execute sandbox code behind our back.
+        // Where workflow code must run (getters, proxies, custom serializers),
+        // the execution is recorded into `options.guestCodeStats`.
+        const str = withGuestCodeStats(options?.guestCodeStats, () => stringify(value, reducers, { operations: hardenedStringifyOperations }));
         return encoder.encode(str);
     },
     deserialize(data, mode, options) {
         const revivers = getReviversForMode(mode, options?.global, options?.extraRevivers);
         const str = decoder.decode(data);
-        return parse(str, revivers);
+        return parse(str, revivers, parseOptions);
     },
     deserializeLegacy(data, mode, options) {
         const revivers = getReviversForMode(mode, options?.global, options?.extraRevivers);
-        return unflatten(data, revivers);
+        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 { parse, stringify, unflatten } from 'devalue';\nimport type { Codec, CodecOptions, SerializationMode } from './codec.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();\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    const str = stringify(value, reducers);\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);\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);\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,
@@ -13,6 +13,8 @@
  * - **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 { GuestCodeStats } from './hardened.js';
 import type { FormatPrefix } from './types.js';
 /**
  * The serialization mode determines which types are supported and how
@@ -20,7 +22,7 @@ import type { FormatPrefix } from './types.js';
  *
  * - `workflow`: Runs inside the workflow VM. Includes class serialization,
  *   step function serialization. No stream handling.
- * - `step`: Runs in the step handler (Node.js). Includes class serialization.
+ * - `step`: Runs in the step executor (Node.js). Includes class serialization.
  *   No step function serialization. Stream handling at call sites.
  * - `client`: Runs on the client side. Includes class serialization.
  *   No step function serialization. Stream handling at call sites.
@@ -49,6 +51,39 @@ export interface CodecOptions {
      * or other mode-specific type revivers.
      */
     extraRevivers?: Record<string, (value: any) => any>;
+    /**
+     * Whether to compress the serialized payload (write side only; zstd is
+     * preferred and gzip is the portable fallback). Reads dispatch compressed
+     * payloads by format prefix; zstd decoding still requires runtime or
+     * registered decoder support. 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;
+    /**
+     * Optional sink populated by the hardened serializer with every
+     * 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*, 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.
+     */
+    guestCodeStats?: GuestCodeStats;
 }
 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,cAAc,EAAE,MAAM,eAAe,CAAC;AACpD,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;;;;;;;;;OASG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IAEpC;;;;;;;;;;;;;;OAcG;IACH,cAAc,CAAC,EAAE,cAAc,CAAC;CACjC;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

@@ -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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29kZWMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvc2VyaWFsaXphdGlvbi9jb2RlYy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7R0FjRyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQ29kZWMgaW50ZXJmYWNlIGZvciBzZXJpYWxpemF0aW9uIGZvcm1hdHMuXG4gKlxuICogQSBjb2RlYyBoYW5kbGVzIHRoZSBjb3JlIHNlcmlhbGl6ZS9kZXNlcmlhbGl6ZSBsb2dpYyBmb3IgYSBzcGVjaWZpY1xuICogd2lyZSBmb3JtYXQgKGRldmFsdWUsIENCT1IsIEpTT04sIGV0Yy4pLiBFYWNoIGNvZGVjIGlzIHJlc3BvbnNpYmxlXG4gKiBmb3IgaGFuZGxpbmcgYWxsIHN1cHBvcnRlZCBkYXRhIHR5cGVzIGludGVybmFsbHkg4oCUIHRoZSBjYWxsZXIgb25seVxuICogc3BlY2lmaWVzIHdoaWNoIHNlcmlhbGl6YXRpb24gbW9kZSB0byB1c2UuXG4gKlxuICogLSAqKmRldmFsdWUqKjogVXNlcyBjdXN0b20gcmVkdWNlcnMvcmV2aXZlcnMgZm9yIERhdGUsIEVycm9yLCBNYXAsIFNldCxcbiAqICAgdHlwZWQgYXJyYXlzLCBjbGFzcyBpbnN0YW5jZXMsIGV0Yy5cbiAqIC0gKipjYm9yKio6IFdvdWxkIGhhbmRsZSBEYXRlLCB0eXBlZCBhcnJheXMsIE1hcCwgU2V0IG5hdGl2ZWx5IHZpYSB0aGVcbiAqICAgQ0JPUiB0eXBlIHN5c3RlbS4gQ2xhc3MgaW5zdGFuY2VzIHdvdWxkIHN0aWxsIG5lZWQgY3VzdG9tIGhhbmRsaW5nLlxuICogLSAqKmpzb24qKjogV291bGQgb25seSBzdXBwb3J0IHN0YW5kYXJkIEpTT04gdHlwZXMgKHByaW1pdGl2ZXMsIGFycmF5cyxcbiAqICAgcGxhaW4gb2JqZWN0cykuIE5vIERhdGUsIE1hcCwgU2V0LCB0eXBlZCBhcnJheXMsIGV0Yy5cbiAqL1xuXG5pbXBvcnQgdHlwZSB7IEZvcm1hdFByZWZpeCB9IGZyb20gJy4vdHlwZXMuanMnO1xuXG4vKipcbiAqIFRoZSBzZXJpYWxpemF0aW9uIG1vZGUgZGV0ZXJtaW5lcyB3aGljaCB0eXBlcyBhcmUgc3VwcG9ydGVkIGFuZCBob3dcbiAqIHRoZXkncmUgaGFuZGxlZC4gRGlmZmVyZW50IG1vZGVzIGNvbXBvc2UgZGlmZmVyZW50IHNldHMgb2YgdHlwZSBoYW5kbGVycy5cbiAqXG4gKiAtIGB3b3JrZmxvd2A6IFJ1bnMgaW5zaWRlIHRoZSB3b3JrZmxvdyBWTS4gSW5jbHVkZXMgY2xhc3Mgc2VyaWFsaXphdGlvbixcbiAqICAgc3RlcCBmdW5jdGlvbiBzZXJpYWxpemF0aW9uLiBObyBzdHJlYW0gaGFuZGxpbmcuXG4gKiAtIGBzdGVwYDogUnVucyBpbiB0aGUgc3RlcCBoYW5kbGVyIChOb2RlLmpzKS4gSW5jbHVkZXMgY2xhc3Mgc2VyaWFsaXphdGlvbi5cbiAqICAgTm8gc3RlcCBmdW5jdGlvbiBzZXJpYWxpemF0aW9uLiBTdHJlYW0gaGFuZGxpbmcgYXQgY2FsbCBzaXRlcy5cbiAqIC0gYGNsaWVudGA6IFJ1bnMgb24gdGhlIGNsaWVudCBzaWRlLiBJbmNsdWRlcyBjbGFzcyBzZXJpYWxpemF0aW9uLlxuICogICBObyBzdGVwIGZ1bmN0aW9uIHNlcmlhbGl6YXRpb24uIFN0cmVhbSBoYW5kbGluZyBhdCBjYWxsIHNpdGVzLlxuICovXG5leHBvcnQgdHlwZSBTZXJpYWxpemF0aW9uTW9kZSA9ICd3b3JrZmxvdycgfCAnc3RlcCcgfCAnY2xpZW50JztcblxuLyoqXG4gKiBPcHRpb25zIHBhc3NlZCB0byBjb2RlYyBzZXJpYWxpemUvZGVzZXJpYWxpemUgdG8gc3VwcG9ydCBWTS1jb250ZXh0XG4gKiBzZXJpYWxpemF0aW9uIGFuZCBtb2RlLXNwZWNpZmljIHR5cGUgaGFuZGxpbmcuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgQ29kZWNPcHRpb25zIHtcbiAgLyoqXG4gICAqIFRoZSBnbG9iYWwgb2JqZWN0IHRvIHVzZSBmb3IgYGluc3RhbmNlb2ZgIGNoZWNrcyBhbmQgY29uc3RydWN0b3JzLlxuICAgKiBEZWZhdWx0cyB0byBgZ2xvYmFsVGhpc2AuIE11c3QgYmUgc2V0IHRvIHRoZSBWTSdzIGdsb2JhbCB3aGVuXG4gICAqIHNlcmlhbGl6aW5nL2Rlc2VyaWFsaXppbmcgZGF0YSB0aGF0IGNyb3NzZXMgVk0gYm91bmRhcmllcy5cbiAgICovXG4gIGdsb2JhbD86IFJlY29yZDxzdHJpbmcsIGFueT47XG5cbiAgLyoqXG4gICAqIEFkZGl0aW9uYWwgcmVkdWNlcnMgdG8gbWVyZ2UgaW50byB0aGUgbW9kZSdzIGRlZmF1bHQgcmVkdWNlcnMuXG4gICAqIFVzZWQgYnkgZGVoeWRyYXRlL2h5ZHJhdGUgZnVuY3Rpb25zIHRoYXQgbmVlZCBzdHJlYW0gaGFuZGxpbmdcbiAgICogb3Igb3RoZXIgbW9kZS1zcGVjaWZpYyB0eXBlIHJlZHVjZXJzLlxuICAgKi9cbiAgZXh0cmFSZWR1Y2Vycz86IFJlY29yZDxzdHJpbmcsICh2YWx1ZTogYW55KSA9PiBhbnk+O1xuXG4gIC8qKlxuICAgKiBBZGRpdGlvbmFsIHJldml2ZXJzIHRvIG1lcmdlIGludG8gdGhlIG1vZGUncyBkZWZhdWx0IHJldml2ZXJzLlxuICAgKiBVc2VkIGJ5IGRlaHlkcmF0ZS9oeWRyYXRlIGZ1bmN0aW9ucyB0aGF0IG5lZWQgc3RyZWFtIGhhbmRsaW5nXG4gICAqIG9yIG90aGVyIG1vZGUtc3BlY2lmaWMgdHlwZSByZXZpdmVycy5cbiAgICovXG4gIGV4dHJhUmV2aXZlcnM/OiBSZWNvcmQ8c3RyaW5nLCAodmFsdWU6IGFueSkgPT4gYW55Pjtcbn1cblxuZXhwb3J0IGludGVyZmFjZSBDb2RlYyB7XG4gIC8qKiBUaGUgNC1jaGFyYWN0ZXIgZm9ybWF0IHByZWZpeCBpZGVudGlmaWVyIChlLmcuIFwiZGV2bFwiLCBcImNib3JcIiwgXCJqc29uXCIpICovXG4gIHJlYWRvbmx5IGZvcm1hdFByZWZpeDogRm9ybWF0UHJlZml4O1xuXG4gIC8qKlxuICAgKiBTZXJpYWxpemUgYSB2YWx1ZSB0byBieXRlcy5cbiAgICpcbiAgICogVGhlIGNvZGVjIGhhbmRsZXMgYWxsIHN1cHBvcnRlZCB0eXBlcyBpbnRlcm5hbGx5IGJhc2VkIG9uIHRoZSBtb2RlLlxuICAgKlxuICAgKiBAcGFyYW0gdmFsdWUgLSBUaGUgdmFsdWUgdG8gc2VyaWFsaXplXG4gICAqIEBwYXJhbSBtb2RlIC0gVGhlIHNlcmlhbGl6YXRpb24gbW9kZVxuICAgKiBAcGFyYW0gb3B0aW9ucyAtIE9wdGlvbmFsIGdsb2JhbCwgZXh0cmEgcmVkdWNlcnMvcmV2aXZlcnNcbiAgICogQHJldHVybnMgVGhlIHNlcmlhbGl6ZWQgcGF5bG9hZCAod2l0aG91dCBmb3JtYXQgcHJlZml4KVxuICAgKi9cbiAgc2VyaWFsaXplKFxuICAgIHZhbHVlOiB1bmtub3duLFxuICAgIG1vZGU6IFNlcmlhbGl6YXRpb25Nb2RlLFxuICAgIG9wdGlvbnM/OiBDb2RlY09wdGlvbnNcbiAgKTogVWludDhBcnJheTtcblxuICAvKipcbiAgICogRGVzZXJpYWxpemUgYnl0ZXMgYmFjayB0byBhIHZhbHVlLlxuICAgKlxuICAgKiBUaGUgY29kZWMgaGFuZGxlcyBhbGwgc3VwcG9ydGVkIHR5cGVzIGludGVybmFsbHkgYmFzZWQgb24gdGhlIG1vZGUuXG4gICAqXG4gICAqIEBwYXJhbSBkYXRhIC0gVGhlIHNlcmlhbGl6ZWQgcGF5bG9hZCAod2l0aG91dCBmb3JtYXQgcHJlZml4KVxuICAgKiBAcGFyYW0gbW9kZSAtIFRoZSBzZXJpYWxpemF0aW9uIG1vZGVcbiAgICogQHBhcmFtIG9wdGlvbnMgLSBPcHRpb25hbCBnbG9iYWwsIGV4dHJhIHJldml2ZXJzXG4gICAqIEByZXR1cm5zIFRoZSBkZXNlcmlhbGl6ZWQgdmFsdWVcbiAgICovXG4gIGRlc2VyaWFsaXplKFxuICAgIGRhdGE6IFVpbnQ4QXJyYXksXG4gICAgbW9kZTogU2VyaWFsaXphdGlvbk1vZGUsXG4gICAgb3B0aW9ucz86IENvZGVjT3B0aW9uc1xuICApOiB1bmtub3duO1xuXG4gIC8qKlxuICAgKiBEZXNlcmlhbGl6ZSBsZWdhY3kgKHByZS1mb3JtYXQtcHJlZml4KSBkYXRhLlxuICAgKiBVc2VkIGZvciBiYWNrd2FyZHMgY29tcGF0aWJpbGl0eSB3aXRoIHNwZWNWZXJzaW9uIDEgcnVucyB0aGF0IHN0b3JlZFxuICAgKiBkYXRhIGFzIHBsYWluIEpTT04gYXJyYXlzIGluc3RlYWQgb2YgYmluYXJ5LlxuICAgKlxuICAgKiBAcGFyYW0gZGF0YSAtIFRoZSBsZWdhY3kgZGF0YVxuICAgKiBAcGFyYW0gbW9kZSAtIFRoZSBzZXJpYWxpemF0aW9uIG1vZGVcbiAgICogQHBhcmFtIG9wdGlvbnMgLSBPcHRpb25hbCBnbG9iYWwsIGV4dHJhIHJldml2ZXJzXG4gICAqIEByZXR1cm5zIFRoZSBkZXNlcmlhbGl6ZWQgdmFsdWVcbiAgICovXG4gIGRlc2VyaWFsaXplTGVnYWN5PyhcbiAgICBkYXRhOiB1bmtub3duLFxuICAgIG1vZGU6IFNlcmlhbGl6YXRpb25Nb2RlLFxuICAgIG9wdGlvbnM/OiBDb2RlY09wdGlvbnNcbiAgKTogdW5rbm93bjtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/dist/serialization/compression.d.ts

@@ -0,0 +1,105 @@
+/**
+ * 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 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,
+ * 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}