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

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/vm-bundle-entry.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Entry point for the VM serialization bundle.
+ *
+ * This file is bundled by esbuild into a self-contained IIFE that
+ * sets up serialize/deserialize on globalThis. The bundled output
+ * is evaluated inside the QuickJS VM during bootstrap.
+ *
+ * TextEncoder, TextDecoder, and Headers are provided by native C
+ * extensions in quickjs-wasi, so no polyfills are needed.
+ */
+export {};
+//# sourceMappingURL=vm-bundle-entry.d.ts.map

package/dist/serialization/vm-bundle-entry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vm-bundle-entry.d.ts","sourceRoot":"","sources":["../../src/serialization/vm-bundle-entry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG"}

package/dist/serialization/vm-bundle-entry.js

@@ -0,0 +1,58 @@
+/**
+ * Entry point for the VM serialization bundle.
+ *
+ * This file is bundled by esbuild into a self-contained IIFE that
+ * sets up serialize/deserialize on globalThis. The bundled output
+ * is evaluated inside the QuickJS VM during bootstrap.
+ *
+ * TextEncoder, TextDecoder, and Headers are provided by native C
+ * extensions in quickjs-wasi, so no polyfills are needed.
+ */
+import { monotonicFactory } from 'ulid';
+import { deserialize, serialize } from './workflow-vm.js';
+// Install on global scope under the public well-known symbols. The
+// snapshot runtime's bootstrap (and the various inline-evaluated JS
+// strings in `snapshot-runtime.ts`) reach the same functions via
+// `globalThis[Symbol.for('workflow-serialize')]` etc.
+globalThis[Symbol.for('workflow-serialize')] = serialize;
+globalThis[Symbol.for('workflow-deserialize')] = deserialize;
+// ULID generator for correlationIds — uses the same monotonicFactory
+// as the node:vm engine. Both inputs MUST be set by the host before the
+// first ULID is drawn, otherwise the seeded-ULID determinism guarantee
+// is silently broken:
+//
+//   * `Math.random` must be replaced with the host's seeded PRNG via
+//     `vm.newFunction('random', …)` (see `quickjs-runtime.ts`, the
+//     `Seeded Math.random` block). Two workflow invocations of the same
+//     run MUST observe an identical random sequence so their
+//     correlationIds collide and the world's EntityConflictError dedup
+//     applies. We pass it explicitly to `monotonicFactory` because
+//     ULID's auto-detect (`detectPRNG`) only knows about
+//     `crypto.getRandomValues` / `crypto.randomBytes`, neither of which
+//     exist in QuickJS. The PRNG is deliberately LATE-BOUND (the arrow
+//     reads `Math.random` at draw time, not at bundle-eval time) so
+//     that this bundle can be evaluated during static VM initialization
+//     — before the per-run seeded PRNG is installed — without capturing
+//     the unseeded built-in. This is also what allows a future VM
+//     snapshot taken after bundle eval to have its PRNG swapped
+//     post-restore.
+//   * `globalThis.__ulidTimestamp` must be a number (typically
+//     `workflowRun.startedAt`). It's used in place of `Date.now()` so
+//     the time portion of the ULID is also stable across concurrent
+//     invocations of the same run.
+//
+// The timestamp prerequisite is validated below — fail loudly rather
+// than fall back to `Date.now()`, which would re-introduce
+// non-determinism that replay relies on us NOT having.
+const ulid = monotonicFactory(() => Math.random());
+globalThis.__generateUlid = () => {
+    const t = globalThis.__ulidTimestamp;
+    if (typeof t !== 'number') {
+        throw new Error('__generateUlid: globalThis.__ulidTimestamp must be a number set by ' +
+            'the host before the serde bundle is evaluated. Without it, ULIDs ' +
+            'would fall back to Date.now() and concurrent workflow invocations ' +
+            'of the same resumption would produce divergent correlationIds.');
+    }
+    return ulid(t);
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,24 @@
+/**
+ * VM-compatible workflow mode serialization.
+ *
+ * This module is designed to be bundled into the QuickJS WASM VM.
+ * It has NO Node.js dependencies (no Buffer, no node:util).
+ *
+ * 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;;;;;;;;GAQG;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,66 @@
+/**
+ * VM-compatible workflow mode serialization.
+ *
+ * This module is designed to be bundled into the QuickJS WASM VM.
+ * It has NO Node.js dependencies (no Buffer, no node:util).
+ *
+ * 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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