@workflow/core 5.0.0-beta.4 → 5.0.0-beta.41

package/dist/serialization/types.d.ts

@@ -0,0 +1,273 @@
+/**
+ * Shared types for the serialization system.
+ */
+import type { RuntimeDecryptionErrorContext } from '@workflow/errors';
+/**
+ * A format prefix is exactly 4 lowercase alphanumeric characters [a-z0-9].
+ *
+ * This is a branded string type — use `isFormatPrefix()` to validate
+ * at runtime. The `SerializationFormat` object provides well-known
+ * constants, but codecs may define additional prefixes.
+ */
+export type FormatPrefix = string & {
+    readonly __brand: 'FormatPrefix';
+};
+/**
+ * Runtime type guard for format prefix strings.
+ *
+ * Validates that a string is exactly 4 characters of [a-z0-9].
+ */
+export declare function isFormatPrefix(value: string): value is FormatPrefix;
+/**
+ * Well-known format prefix constants. Codecs may define additional ones.
+ */
+export declare const SerializationFormat: {
+    /** devalue stringify/parse with TextEncoder/TextDecoder */
+    readonly DEVALUE_V1: FormatPrefix;
+    /** Encrypted payload (inner payload has its own format prefix) */
+    readonly ENCRYPTED: FormatPrefix;
+    /**
+     * Sealed payload — asymmetrically encrypted to a run's X25519 public key
+     * (inner payload has its own format prefix).
+     *
+     * Used for *cross-run* writes (hook payloads, forwarded stream frames),
+     * where the writer holds only the recipient run's public key and therefore
+     * cannot decrypt. A run's own payloads continue to use {@link ENCRYPTED}.
+     * See `sealed-box.ts` for the construction.
+     */
+    readonly SEALED: FormatPrefix;
+    /** Gzip-compressed payload (inner payload has its own format prefix) */
+    readonly GZIP: FormatPrefix;
+    /** Zstandard-compressed payload (inner payload has its own format prefix) */
+    readonly ZSTD: FormatPrefix;
+};
+/**
+ * Wire-framing format identifier carried in the serialized
+ * `ReadableStream` ref's `framing` field.
+ *
+ * - absent / `'raw'`: chunks are written to the transport verbatim
+ *   (legacy format — no auto-reconnect support).
+ * - `'framed-v1'`: each chunk is wrapped in a 4-byte big-endian length
+ *   prefix, allowing the reader to identify chunk boundaries and
+ *   transparently reconnect on transient stream errors.
+ */
+export type ByteStreamFraming = 'raw' | 'framed-v1';
+/**
+ * Types that need specialized handling when serialized/deserialized.
+ * If a type is added here, it MUST also be added to the `Serializable`
+ * type in `schemas.ts`.
+ */
+export interface SerializableSpecial {
+    ArrayBuffer: string;
+    BigInt: string;
+    BigInt64Array: string;
+    BigUint64Array: string;
+    Date: string;
+    DOMException: {
+        message: string;
+        name: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    FatalError: {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    Float32Array: string;
+    Float64Array: string;
+    Error: {
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    EvalError: {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    Headers: [string, string][];
+    HookConflictError: {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        token: string;
+        conflictingRunId?: string;
+    };
+    Int8Array: string;
+    Int16Array: string;
+    Int32Array: string;
+    Map: [any, any][];
+    RangeError: {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    ReadableStream: {
+        name: string;
+        type?: 'bytes';
+        startIndex?: number;
+        /**
+         * Wire-framing format for byte streams. See {@link ByteStreamFraming}
+         * and `getByteFramingStream` / `getByteUnframingStream`.
+         *
+         * Only meaningful when `type === 'bytes'`. Absent on object streams
+         * (which always use length-prefixed devalue framing) and on legacy
+         * byte streams written by SDKs that predate framing support — those
+         * are interpreted as `'raw'` by the consumer.
+         */
+        framing?: ByteStreamFraming;
+    } | {
+        bodyInit: any;
+    };
+    ReferenceError: {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    RegExp: {
+        source: string;
+        flags: string;
+    };
+    /**
+     * `retryAfter` is serialized as a numeric epoch timestamp rather than a
+     * `Date` to be realm-safe. The Date reducer uses `instanceof global.Date`,
+     * which fails for Dates from a different VM realm.
+     */
+    RetryableError: {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        retryAfter: number;
+    };
+    RuntimeDecryptionError: {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        context?: RuntimeDecryptionErrorContext;
+    };
+    Request: {
+        method: string;
+        url: string;
+        headers: Headers;
+        body: Request['body'];
+        duplex: Request['duplex'];
+        responseWritable?: WritableStream<Response>;
+        signal?: AbortSignal;
+    };
+    Response: {
+        type: Response['type'];
+        url: string;
+        status: number;
+        statusText: string;
+        headers: Headers;
+        body: Response['body'];
+        redirected: boolean;
+    };
+    Class: {
+        classId: string;
+    };
+    Instance: {
+        classId: string;
+        data: unknown;
+    };
+    Set: any[];
+    SyntaxError: {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    StepFunction: {
+        stepId: string;
+        closureVars?: Record<string, any>;
+        /**
+         * Captured lexical `this` for step proxies that were created via
+         * `useStep(...).bind(thisArg)` (the SWC plugin emits this for nested
+         * arrow steps that close over their enclosing function's `this`).
+         * The reviver re-binds the freshly-created proxy to this value so the
+         * binding survives serialization round-trips.
+         */
+        boundThis?: unknown;
+        /**
+         * Prefilled arguments captured when the user (rather than the SWC
+         * plugin) called `useStep(...).bind(thisArg, x, y)`. The reviver
+         * re-applies these alongside `boundThis` so partial application
+         * survives serialization. The SWC plugin only ever emits
+         * `.bind(this)` with no extra args today; this slot exists so a
+         * hand-written `.bind(thisArg, x)` doesn't silently lose `x` after
+         * round-tripping through the reducer/reviver.
+         */
+        boundArgs?: unknown[];
+    };
+    TypeError: {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    URIError: {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    URL: string;
+    WorkflowFunction: {
+        workflowId: string;
+    };
+    URLSearchParams: string;
+    Uint8Array: string;
+    Uint8ClampedArray: string;
+    Uint16Array: string;
+    Uint32Array: string;
+    AggregateError: {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        errors: unknown[];
+    };
+    WritableStream: {
+        name: string;
+        /**
+         * The runId of the workflow run that owns the underlying server
+         * stream. Present only when the writable was forwarded across a
+         * `start()` boundary (parent → child). When omitted, the writable
+         * belongs to the receiving run (the normal in-run case).
+         */
+        runId?: string;
+        /**
+         * The deployment that owns the server stream. Carried with `runId`
+         * so a child running on a newer deployment can encrypt chunks with
+         * the parent's key without fetching the parent run first.
+         */
+        deploymentId?: string;
+        /**
+         * The owning run's X25519 public key (base64), when it has one.
+         *
+         * Lets the receiving run seal frames to the stream's owner with no
+         * lookup at all — neither a run fetch nor a key-API round trip. The
+         * owner derives this locally when it creates the stream, so including
+         * it here is free. Absent for runs created by older SDKs, in which
+         * case the receiver falls back to resolving the owner's symmetric key.
+         */
+        encryptionPublicKey?: string;
+    };
+    AbortController: {
+        streamName: string;
+        hookToken: string;
+        aborted: boolean;
+        reason?: unknown;
+    };
+    AbortSignal: {
+        streamName: string;
+        hookToken: string;
+        aborted: boolean;
+        reason?: unknown;
+    };
+}
+export type Reducers = {
+    [K in keyof SerializableSpecial]: (value: any) => SerializableSpecial[K] | false;
+};
+export type Revivers = {
+    [K in keyof SerializableSpecial]: (value: SerializableSpecial[K]) => any;
+};
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/serialization/types.ts"],"names":[],"mappings":"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"}

package/dist/serialization/types.js

@@ -0,0 +1,35 @@
+/**
+ * Shared types for the serialization system.
+ */
+/**
+ * Runtime type guard for format prefix strings.
+ *
+ * Validates that a string is exactly 4 characters of [a-z0-9].
+ */
+export function isFormatPrefix(value) {
+    return value.length === 4 && /^[a-z0-9]{4}$/.test(value);
+}
+/**
+ * Well-known format prefix constants. Codecs may define additional ones.
+ */
+export const SerializationFormat = {
+    /** devalue stringify/parse with TextEncoder/TextDecoder */
+    DEVALUE_V1: 'devl',
+    /** Encrypted payload (inner payload has its own format prefix) */
+    ENCRYPTED: 'encr',
+    /**
+     * Sealed payload — asymmetrically encrypted to a run's X25519 public key
+     * (inner payload has its own format prefix).
+     *
+     * Used for *cross-run* writes (hook payloads, forwarded stream frames),
+     * where the writer holds only the recipient run's public key and therefore
+     * cannot decrypt. A run's own payloads continue to use {@link ENCRYPTED}.
+     * See `sealed-box.ts` for the construction.
+     */
+    SEALED: 'encp',
+    /** Gzip-compressed payload (inner payload has its own format prefix) */
+    GZIP: 'gzip',
+    /** Zstandard-compressed payload (inner payload has its own format prefix) */
+    ZSTD: 'zstd',
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/serialization/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AAeH;;;;GAIG;AACH,MAAM,UAAU,cAAc,CAAC,KAAa;IAC1C,OAAO,KAAK,CAAC,MAAM,KAAK,CAAC,IAAI,eAAe,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AAC3D,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG;IACjC,2DAA2D;IAC3D,UAAU,EAAE,MAAsB;IAClC,kEAAkE;IAClE,SAAS,EAAE,MAAsB;IACjC;;;;;;;;OAQG;IACH,MAAM,EAAE,MAAsB;IAC9B,wEAAwE;IACxE,IAAI,EAAE,MAAsB;IAC5B,6EAA6E;IAC7E,IAAI,EAAE,MAAsB;CACpB,CAAC","sourcesContent":["/**\n * Shared types for the serialization system.\n */\n\nimport type { RuntimeDecryptionErrorContext } from '@workflow/errors';\n\n// ---- Format Prefix ----\n\n/**\n * A format prefix is exactly 4 lowercase alphanumeric characters [a-z0-9].\n *\n * This is a branded string type — use `isFormatPrefix()` to validate\n * at runtime. The `SerializationFormat` object provides well-known\n * constants, but codecs may define additional prefixes.\n */\nexport type FormatPrefix = string & { readonly __brand: 'FormatPrefix' };\n\n/**\n * Runtime type guard for format prefix strings.\n *\n * Validates that a string is exactly 4 characters of [a-z0-9].\n */\nexport function isFormatPrefix(value: string): value is FormatPrefix {\n  return value.length === 4 && /^[a-z0-9]{4}$/.test(value);\n}\n\n/**\n * Well-known format prefix constants. Codecs may define additional ones.\n */\nexport const SerializationFormat = {\n  /** devalue stringify/parse with TextEncoder/TextDecoder */\n  DEVALUE_V1: 'devl' as FormatPrefix,\n  /** Encrypted payload (inner payload has its own format prefix) */\n  ENCRYPTED: 'encr' as FormatPrefix,\n  /**\n   * Sealed payload — asymmetrically encrypted to a run's X25519 public key\n   * (inner payload has its own format prefix).\n   *\n   * Used for *cross-run* writes (hook payloads, forwarded stream frames),\n   * where the writer holds only the recipient run's public key and therefore\n   * cannot decrypt. A run's own payloads continue to use {@link ENCRYPTED}.\n   * See `sealed-box.ts` for the construction.\n   */\n  SEALED: 'encp' as FormatPrefix,\n  /** Gzip-compressed payload (inner payload has its own format prefix) */\n  GZIP: 'gzip' as FormatPrefix,\n  /** Zstandard-compressed payload (inner payload has its own format prefix) */\n  ZSTD: 'zstd' as FormatPrefix,\n} as const;\n\n// ---- Serializable Types ----\n\n/**\n * Wire-framing format identifier carried in the serialized\n * `ReadableStream` ref's `framing` field.\n *\n * - absent / `'raw'`: chunks are written to the transport verbatim\n *   (legacy format — no auto-reconnect support).\n * - `'framed-v1'`: each chunk is wrapped in a 4-byte big-endian length\n *   prefix, allowing the reader to identify chunk boundaries and\n *   transparently reconnect on transient stream errors.\n */\nexport type ByteStreamFraming = 'raw' | 'framed-v1';\n\n/**\n * Types that need specialized handling when serialized/deserialized.\n * If a type is added here, it MUST also be added to the `Serializable`\n * type in `schemas.ts`.\n */\nexport interface SerializableSpecial {\n  ArrayBuffer: string; // base64 string\n  BigInt: string; // string representation of bigint\n  BigInt64Array: string; // base64 string\n  BigUint64Array: string; // base64 string\n  Date: string; // ISO string\n  DOMException: {\n    message: string;\n    name: string;\n    stack?: string;\n    cause?: unknown;\n  };\n  FatalError: { message: string; stack?: string; cause?: unknown };\n  Float32Array: string; // base64 string\n  Float64Array: string; // base64 string\n  Error: { name: string; message: string; stack?: string; cause?: unknown };\n  EvalError: { message: string; stack?: string; cause?: unknown };\n  Headers: [string, string][];\n  HookConflictError: {\n    message: string;\n    stack?: string;\n    cause?: unknown;\n    token: string;\n    // TODO: Make this required when HookConflictError.conflictingRunId is required.\n    conflictingRunId?: string;\n  };\n  Int8Array: string; // base64 string\n  Int16Array: string; // base64 string\n  Int32Array: string; // base64 string\n  Map: [any, any][];\n  RangeError: { message: string; stack?: string; cause?: unknown };\n  ReadableStream:\n    | {\n        name: string;\n        type?: 'bytes';\n        startIndex?: number;\n        /**\n         * Wire-framing format for byte streams. See {@link ByteStreamFraming}\n         * and `getByteFramingStream` / `getByteUnframingStream`.\n         *\n         * Only meaningful when `type === 'bytes'`. Absent on object streams\n         * (which always use length-prefixed devalue framing) and on legacy\n         * byte streams written by SDKs that predate framing support — those\n         * are interpreted as `'raw'` by the consumer.\n         */\n        framing?: ByteStreamFraming;\n      }\n    | { bodyInit: any };\n  ReferenceError: { message: string; stack?: string; cause?: unknown };\n  RegExp: { source: string; flags: string };\n  /**\n   * `retryAfter` is serialized as a numeric epoch timestamp rather than a\n   * `Date` to be realm-safe. The Date reducer uses `instanceof global.Date`,\n   * which fails for Dates from a different VM realm.\n   */\n  RetryableError: {\n    message: string;\n    stack?: string;\n    cause?: unknown;\n    retryAfter: number;\n  };\n  RuntimeDecryptionError: {\n    message: string;\n    stack?: string;\n    cause?: unknown;\n    context?: RuntimeDecryptionErrorContext;\n  };\n  Request: {\n    method: string;\n    url: string;\n    headers: Headers;\n    body: Request['body'];\n    duplex: Request['duplex'];\n    responseWritable?: WritableStream<Response>;\n    signal?: AbortSignal;\n  };\n  Response: {\n    type: Response['type'];\n    url: string;\n    status: number;\n    statusText: string;\n    headers: Headers;\n    body: Response['body'];\n    redirected: boolean;\n  };\n  Class: {\n    classId: string;\n  };\n  Instance: {\n    classId: string;\n    data: unknown;\n  };\n  Set: any[];\n  SyntaxError: { message: string; stack?: string; cause?: unknown };\n  StepFunction: {\n    stepId: string;\n    closureVars?: Record<string, any>;\n    /**\n     * Captured lexical `this` for step proxies that were created via\n     * `useStep(...).bind(thisArg)` (the SWC plugin emits this for nested\n     * arrow steps that close over their enclosing function's `this`).\n     * The reviver re-binds the freshly-created proxy to this value so the\n     * binding survives serialization round-trips.\n     */\n    boundThis?: unknown;\n    /**\n     * Prefilled arguments captured when the user (rather than the SWC\n     * plugin) called `useStep(...).bind(thisArg, x, y)`. The reviver\n     * re-applies these alongside `boundThis` so partial application\n     * survives serialization. The SWC plugin only ever emits\n     * `.bind(this)` with no extra args today; this slot exists so a\n     * hand-written `.bind(thisArg, x)` doesn't silently lose `x` after\n     * round-tripping through the reducer/reviver.\n     */\n    boundArgs?: unknown[];\n  };\n  TypeError: { message: string; stack?: string; cause?: unknown };\n  URIError: { message: string; stack?: string; cause?: unknown };\n  URL: string;\n  WorkflowFunction: {\n    workflowId: string;\n  };\n  URLSearchParams: string;\n  Uint8Array: string; // base64 string\n  Uint8ClampedArray: string; // base64 string\n  Uint16Array: string; // base64 string\n  Uint32Array: string; // base64 string\n  AggregateError: {\n    message: string;\n    stack?: string;\n    cause?: unknown;\n    errors: unknown[];\n  };\n  WritableStream: {\n    name: string;\n    /**\n     * The runId of the workflow run that owns the underlying server\n     * stream. Present only when the writable was forwarded across a\n     * `start()` boundary (parent → child). When omitted, the writable\n     * belongs to the receiving run (the normal in-run case).\n     */\n    runId?: string;\n    /**\n     * The deployment that owns the server stream. Carried with `runId`\n     * so a child running on a newer deployment can encrypt chunks with\n     * the parent's key without fetching the parent run first.\n     */\n    deploymentId?: string;\n    /**\n     * The owning run's X25519 public key (base64), when it has one.\n     *\n     * Lets the receiving run seal frames to the stream's owner with no\n     * lookup at all — neither a run fetch nor a key-API round trip. The\n     * owner derives this locally when it creates the stream, so including\n     * it here is free. Absent for runs created by older SDKs, in which\n     * case the receiver falls back to resolving the owner's symmetric key.\n     */\n    encryptionPublicKey?: string;\n  };\n  AbortController: {\n    streamName: string;\n    hookToken: string;\n    aborted: boolean;\n    reason?: unknown;\n  };\n  AbortSignal: {\n    streamName: string;\n    hookToken: string;\n    aborted: boolean;\n    reason?: unknown;\n  };\n}\n\nexport type Reducers = {\n  [K in keyof SerializableSpecial]: (\n    value: any\n  ) => SerializableSpecial[K] | false;\n};\n\nexport type Revivers = {\n  [K in keyof SerializableSpecial]: (value: SerializableSpecial[K]) => any;\n};\n"]}

package/dist/serialization/workflow-vm.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Host-side reference implementation of the QuickJS engine's workflow-mode
+ * wire codec.
+ *
+ * The QuickJS engine serializes through handles on the host
+ * (runtime/quickjs-serde.ts); this module is the value-space equivalent of
+ * that codec and is used by tests to build wire fixtures and assert
+ * byte-level parity. It has NO Node.js dependencies (no Buffer, no
+ * node:util), which is also what made it bundleable into the VM before the
+ * serde moved host-side.
+ *
+ * Produces and consumes the same wire format as the Node.js workflow.ts —
+ * format-prefixed devalue data ("devl" + devalue.stringify output).
+ */
+/**
+ * Serialize a value to format-prefixed bytes.
+ *
+ * @param value - The value to serialize
+ * @returns Uint8Array with "devl" prefix + devalue payload
+ */
+export declare function serialize(value: unknown): Uint8Array;
+/**
+ * Deserialize format-prefixed bytes back to a value.
+ *
+ * @param data - Uint8Array with format prefix, or legacy non-binary data
+ * @returns The deserialized value
+ */
+export declare function deserialize(data: Uint8Array | unknown): unknown;
+//# sourceMappingURL=workflow-vm.d.ts.map

package/dist/serialization/workflow-vm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-vm.d.ts","sourceRoot":"","sources":["../../src/serialization/workflow-vm.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAiBH;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,GAAG,UAAU,CAOpD;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,GAAG,OAAO,CA0B/D"}

package/dist/serialization/workflow-vm.js

@@ -0,0 +1,71 @@
+/**
+ * Host-side reference implementation of the QuickJS engine's workflow-mode
+ * wire codec.
+ *
+ * The QuickJS engine serializes through handles on the host
+ * (runtime/quickjs-serde.ts); this module is the value-space equivalent of
+ * that codec and is used by tests to build wire fixtures and assert
+ * byte-level parity. It has NO Node.js dependencies (no Buffer, no
+ * node:util), which is also what made it bundleable into the VM before the
+ * serde moved host-side.
+ *
+ * Produces and consumes the same wire format as the Node.js workflow.ts —
+ * format-prefixed devalue data ("devl" + devalue.stringify output).
+ */
+import { devalueVmCodec } from './codec-devalue-vm.js';
+import { isFormatPrefix, SerializationFormat } from './types.js';
+const FORMAT_PREFIX_LENGTH = 4;
+let _encoder;
+let _decoder;
+function getEncoder() {
+    if (!_encoder)
+        _encoder = new globalThis.TextEncoder();
+    return _encoder;
+}
+function getDecoder() {
+    if (!_decoder)
+        _decoder = new globalThis.TextDecoder();
+    return _decoder;
+}
+/**
+ * Serialize a value to format-prefixed bytes.
+ *
+ * @param value - The value to serialize
+ * @returns Uint8Array with "devl" prefix + devalue payload
+ */
+export function serialize(value) {
+    const payload = devalueVmCodec.serialize(value, 'workflow');
+    const prefix = getEncoder().encode(SerializationFormat.DEVALUE_V1);
+    const result = new Uint8Array(prefix.length + payload.length);
+    result.set(prefix, 0);
+    result.set(payload, prefix.length);
+    return result;
+}
+/**
+ * Deserialize format-prefixed bytes back to a value.
+ *
+ * @param data - Uint8Array with format prefix, or legacy non-binary data
+ * @returns The deserialized value
+ */
+export function deserialize(data) {
+    // Legacy: non-binary data
+    if (!(data instanceof Uint8Array)) {
+        if (devalueVmCodec.deserializeLegacy) {
+            return devalueVmCodec.deserializeLegacy(data, 'workflow');
+        }
+        throw new Error('Cannot deserialize non-binary data without legacy support');
+    }
+    if (data.length < FORMAT_PREFIX_LENGTH) {
+        throw new Error('Data too short to contain format prefix');
+    }
+    const prefixStr = getDecoder().decode(data.subarray(0, FORMAT_PREFIX_LENGTH));
+    if (!isFormatPrefix(prefixStr)) {
+        throw new Error(`Invalid format prefix: "${prefixStr}"`);
+    }
+    if (prefixStr === SerializationFormat.DEVALUE_V1) {
+        const payload = data.subarray(FORMAT_PREFIX_LENGTH);
+        return devalueVmCodec.deserialize(payload, 'workflow');
+    }
+    throw new Error(`Unsupported serialization format: ${prefixStr}`);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/serialization/workflow.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Workflow mode serialization.
+ *
+ * Provides serialize/deserialize for use inside the workflow execution
+ * environment (QuickJS VM or Node.js vm). It is:
+ * - Synchronous (no async operations)
+ * - No encryption (encryption is handled outside the VM on the host side)
+ *
+ * Designed to be bundled into the workflow code by esbuild and executed
+ * inside the sandboxed VM.
+ */
+import type { CodecOptions } from './codec.js';
+/**
+ * Serialize a value for storage/transmission from the workflow environment.
+ *
+ * @param value - The value to serialize
+ * @param options - Optional global, extra reducers/revivers for VM-context serialization
+ * @returns Format-prefixed serialized bytes
+ */
+export declare function serialize(value: unknown, options?: CodecOptions): Uint8Array;
+/**
+ * Deserialize a value received in the workflow environment.
+ *
+ * @param data - Format-prefixed serialized bytes, or legacy data
+ * @param options - Optional global, extra revivers for VM-context deserialization
+ * @returns The deserialized value
+ */
+export declare function deserialize(data: Uint8Array | unknown, options?: CodecOptions): unknown;
+//# sourceMappingURL=workflow.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"workflow.d.ts","sourceRoot":"","sources":["../../src/serialization/workflow.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAM/C;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,UAAU,CAW5E;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,UAAU,GAAG,OAAO,EAC1B,OAAO,CAAC,EAAE,YAAY,GACrB,OAAO,CAiBT"}

package/dist/serialization/workflow.js

@@ -0,0 +1,54 @@
+/**
+ * Workflow mode serialization.
+ *
+ * Provides serialize/deserialize for use inside the workflow execution
+ * environment (QuickJS VM or Node.js vm). It is:
+ * - Synchronous (no async operations)
+ * - No encryption (encryption is handled outside the VM on the host side)
+ *
+ * Designed to be bundled into the workflow code by esbuild and executed
+ * inside the sandboxed VM.
+ */
+import { SerializationError } from '@workflow/errors';
+import { devalueCodec } from './codec-devalue.js';
+import { formatSerializationError } from './errors.js';
+import { decodeFormatPrefix, encodeWithFormatPrefix } from './format.js';
+import { SerializationFormat } from './types.js';
+/**
+ * Serialize a value for storage/transmission from the workflow environment.
+ *
+ * @param value - The value to serialize
+ * @param options - Optional global, extra reducers/revivers for VM-context serialization
+ * @returns Format-prefixed serialized bytes
+ */
+export function serialize(value, options) {
+    try {
+        const payload = devalueCodec.serialize(value, 'workflow', options);
+        return encodeWithFormatPrefix(SerializationFormat.DEVALUE_V1, payload);
+    }
+    catch (error) {
+        const { message, hint } = formatSerializationError('workflow value', error);
+        throw new SerializationError(message, { hint, cause: error });
+    }
+}
+/**
+ * Deserialize a value received in the workflow environment.
+ *
+ * @param data - Format-prefixed serialized bytes, or legacy data
+ * @param options - Optional global, extra revivers for VM-context deserialization
+ * @returns The deserialized value
+ */
+export function deserialize(data, options) {
+    if (!(data instanceof Uint8Array)) {
+        if (devalueCodec.deserializeLegacy) {
+            return devalueCodec.deserializeLegacy(data, 'workflow', options);
+        }
+        throw new Error('Cannot deserialize non-binary data without legacy support');
+    }
+    const { format, payload } = decodeFormatPrefix(data);
+    if (format === SerializationFormat.DEVALUE_V1) {
+        return devalueCodec.deserialize(payload, 'workflow', options);
+    }
+    throw new Error(`Unsupported serialization format: ${format}`);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/serialization-format.d.ts

@@ -5,11 +5,36 @@
  * dispatch, and shared types/classes used by all environments (runtime, web
  * o11y, CLI o11y). It has NO Node.js dependencies.
  */
+/**
+ * Re-exported from the envelope layer so browser consumers (web dashboard,
+ * web-shared) can resolve key material without importing
+ * `@workflow/core/serialization`, whose module graph reaches Node built-ins
+ * (`node:util`, `node:async_hooks`) and cannot be bundled for the browser.
+ *
+ * Everything below is Web Crypto only: `serialization/encryption.ts`,
+ * `encryption.ts` and `sealed-box.ts` are all free of Node dependencies.
+ */
+export { type DecryptionKey, decrypt as decryptEnvelope, deriveRunPayloadKeys, encrypt as encryptEnvelope, isRunPayloadKeys, isSealTarget, type PayloadKey, type RunPayloadKeys, runPayloadKeys, type SealTarget, sealTo, } from './serialization/encryption.js';
 export declare const SerializationFormat: {
     /** devalue stringify/parse with TextEncoder/TextDecoder */
     readonly DEVALUE_V1: "devl";
     /** Encrypted payload (inner payload has its own format prefix after decryption) */
     readonly ENCRYPTED: "encr";
+    /**
+     * Sealed payload — asymmetrically encrypted to a run's X25519 public key
+     * (inner payload has its own format prefix after opening).
+     *
+     * Written by cross-run writers that hold only the recipient run's public
+     * key. Opening it requires the run's private scalar rather than the
+     * symmetric per-run key, so o11y display treats it as ciphertext via
+     * {@link isEncryptedData} but {@link hydrateDataWithKey} does not attempt
+     * an AES-GCM decrypt on it.
+     */
+    readonly SEALED: "encp";
+    /** Gzip-compressed payload (inner payload has its own format prefix after decompression) */
+    readonly GZIP: "gzip";
+    /** Zstandard-compressed payload (inner payload has its own format prefix after decompression) */
+    readonly ZSTD: "zstd";
 };
 export type SerializationFormatType = (typeof SerializationFormat)[keyof typeof SerializationFormat];
 /**
@@ -38,10 +63,36 @@ export declare const ENCRYPTED_PLACEHOLDER = "\uD83D\uDD12 Encrypted";
  */
 export declare function isExpiredStub(data: unknown): boolean;
 /**
- * Check if a binary value has the 'encr' format prefix indicating encryption.
+ * Check if a binary value is ciphertext — either a symmetrically encrypted
+ * payload ('encr') or a sealed cross-run payload ('encp').
+ *
+ * This is the predicate display layers want: both schemes are opaque bytes
+ * that must not be fed to the devalue parser, and both render as the same
+ * "Encrypted" affordance in the CLI and web UI. Use {@link isSealedData} when
+ * the *scheme* matters — notably when choosing a decryption path, since a
+ * sealed payload needs the run's private scalar rather than its symmetric key.
+ *
  * Browser-safe — does not depend on the full serialization module.
  */
 export declare function isEncryptedData(data: unknown): boolean;
+/**
+ * Check if a binary value has the 'encp' format prefix, indicating a sealed
+ * (asymmetrically encrypted) cross-run payload.
+ *
+ * Browser-safe — does not depend on the full serialization module.
+ */
+export declare function isSealedData(data: unknown): boolean;
+/**
+ * Check if a binary value has a compression format prefix ('gzip' or 'zstd').
+ * Browser-safe — does not depend on the full serialization module.
+ */
+export declare function isCompressedData(data: unknown): boolean;
+/**
+ * Register a browser zstd decoder (e.g. a WASM-backed one). The web o11y UI
+ * calls this at init so `hydrateDataWithKey` can inflate zstd payloads after
+ * client-side decryption. Node readers use `node:zlib` and ignore this.
+ */
+export declare function registerZstdDecoder(decoder: (payload: Uint8Array) => Promise<Uint8Array>): void;
 /**
  * A map of type name → reviver function, used by devalue's `parse`/`unflatten`.
  * Each environment (runtime, web, CLI) provides its own set.
@@ -70,11 +121,15 @@ export declare function hydrateData(value: unknown, revivers: Revivers): unknown
  * decryption. Used by o11y tooling (web UI, CLI) when the user requests
  * decryption.
  *
- * @param value - The value to hydrate (may be encrypted)
+ * @param value - The value to hydrate (may be encrypted or sealed)
  * @param revivers - Devalue revivers for deserialization
- * @param key - AES-256 encryption key (if provided, encrypted data will be decrypted)
+ * @param key - The run's key material. Pass `RunPayloadKeys` (from
+ *   `deriveRunPayloadKeys`) to open both symmetric (`encr`) and sealed
+ *   (`encp`) payloads; a bare `CryptoKey` opens only the symmetric ones.
+ *   Typed as a read capability so a write-only seal target — which could open
+ *   neither scheme — is rejected at compile time rather than failing here.
  */
-export declare function hydrateDataWithKey(value: unknown, revivers: Revivers, key: import('./encryption.js').CryptoKey | undefined): Promise<unknown>;
+export declare function hydrateDataWithKey(value: unknown, revivers: Revivers, key: import('./serialization/encryption.js').DecryptionKey | undefined): Promise<unknown>;
 /** Marker for stream reference objects rendered as links in the UI */
 export declare const STREAM_REF_TYPE = "__workflow_stream_ref__";
 /** A stream reference for UI display */
@@ -158,6 +213,7 @@ export declare function hydrateResourceIO<T extends {
     stepId?: string;
     hookId?: string;
     eventId?: string;
+    eventType?: string;
     input?: any;
     output?: any;
     metadata?: any;