serialization.test.ts

import { runInContext } from 'node:vm';
import type { WorkflowRuntimeError } from '@workflow/errors';
import { WORKFLOW_DESERIALIZE, WORKFLOW_SERIALIZE } from '@workflow/serde';
import { beforeAll, describe, expect, it, vi } from 'vitest';
import { registerSerializationClass } from './class-serialization.js';
import { decrypt, encrypt, importKey } from './encryption.js';
import { getStepFunction, registerStepFunction } from './private.js';
import {
  decodeFormatPrefix,
  dehydrateStepArguments,
  dehydrateStepReturnValue,
  dehydrateWorkflowArguments,
  dehydrateWorkflowReturnValue,
  getCommonRevivers,
  getDeserializeStream,
  getSerializeStream,
  getStreamType,
  getWorkflowReducers,
  hydrateStepArguments,
  hydrateStepReturnValue,
  hydrateWorkflowArguments,
  hydrateWorkflowReturnValue,
  isEncrypted,
  maybeDecrypt,
  maybeEncrypt,
  SerializationFormat,
} from './serialization.js';
import {
  ABORT_HOOK_TOKEN,
  ABORT_STREAM_NAME,
  STABLE_ULID,
  STREAM_NAME_SYMBOL,
} from './symbols.js';
import { createContext } from './vm/index.js';

vi.mock('./runtime/world.js', () => ({
  getWorld: vi.fn(() => ({
    writeToStream: vi.fn().mockResolvedValue(undefined),
    writeToStreamMulti: vi.fn().mockResolvedValue(undefined),
    closeStream: vi.fn().mockResolvedValue(undefined),
    readFromStream: vi.fn().mockResolvedValue(
      new ReadableStream({
        start(c) {
          c.close();
        },
      })
    ),
    listStreamsByRunId: vi.fn().mockResolvedValue([]),
  })),
}));

const mockRunId = 'wrun_mockidnumber0001';
const noEncryptionKey = undefined;

describe('getStreamType', () => {
  it('should return `undefined` for a regular stream', () => {
    const stream = new ReadableStream();
    expect(stream.locked).toBe(false);
    expect(getStreamType(stream)).toBeUndefined();
    expect(stream.locked).toBe(false);
  });

  it('should return "bytes" for a byte stream', () => {
    const stream = new ReadableStream({
      type: 'bytes',
    });
    expect(stream.locked).toBe(false);
    expect(getStreamType(stream)).toBe('bytes');
    expect(stream.locked).toBe(false);
  });
});

describe('workflow arguments', () => {
  const { context, globalThis: vmGlobalThis } = createContext({
    seed: 'test',
    fixedTimestamp: 1714857600000,
  });

  it('should work with Date', async () => {
    const date = new Date('2025-07-17T04:30:34.824Z');
    const serialized = await dehydrateWorkflowArguments(
      date,
      mockRunId,
      noEncryptionKey,
      []
    );
    expect(serialized).toMatchInlineSnapshot(`
      Uint8Array [
        100,
        101,
        118,
        108,
        91,
        91,
        34,
        68,
        97,
        116,
        101,
        34,
        44,
        49,
        93,
        44,
        34,
        50,
        48,
        50,
        53,
        45,
        48,
        55,
        45,
        49,
        55,
        84,
        48,
        52,
        58,
        51,
        48,
        58,
        51,
        52,
        46,
        56,
        50,
        52,
        90,
        34,
        93,
      ]
    `);

    const hydrated = await hydrateWorkflowArguments(
      serialized,
      mockRunId,
      noEncryptionKey,
      vmGlobalThis
    );
    vmGlobalThis.val = hydrated;

    expect(runInContext('val instanceof Date', context)).toBe(true);
    expect(hydrated.getTime()).toEqual(date.getTime());
  });

  it('should work with invalid Date', async () => {
    const date = new Date('asdf');
    const serialized = await dehydrateWorkflowArguments(
      date,
      mockRunId,
      noEncryptionKey,
      []
    );
    expect(serialized).toMatchInlineSnapshot(`
      Uint8Array [
        100,
        101,
        118,
        108,
        91,
        91,
        34,
        68,
        97,
        116,
        101,
        34,
        44,
        49,
        93,
        44,
        34,
        46,
        34,
        93,
      ]
    `);

    const hydrated = await hydrateWorkflowArguments(
      serialized,
      mockRunId,
      noEncryptionKey,
      vmGlobalThis
    );
    vmGlobalThis.val = hydrated;

    expect(runInContext('val instanceof Date', context)).toBe(true);
    expect(hydrated.getTime()).toEqual(NaN);
  });

  it('should work with BigInt', async () => {
    const bigInt = BigInt('9007199254740992');
    const serialized = await dehydrateWorkflowArguments(
      bigInt,
      mockRunId,
      noEncryptionKey,
      []
    );
    expect(serialized).toMatchInlineSnapshot(`
      Uint8Array [
        100,
        101,
        118,
        108,
        91,
        91,
        34,
        66,
        105,
        103,
        73,
        110,
        116,
        34,
        44,
        49,
        93,
        44,
        34,
        57,
        48,
        48,
        55,
        49,
        57,
        57,
        50,
        53,
        52,
        55,
        52,
        48,
        57,
        57,
        50,
        34,
        93,
      ]
    `);

    const hydrated = await hydrateWorkflowArguments(
      serialized,
      mockRunId,
      noEncryptionKey,
      vmGlobalThis
    );
    expect(hydrated).toBe(BigInt(9007199254740992));
    expect(typeof hydrated).toBe('bigint');
  });

  it('should work with BigInt negative', async () => {
    const bigInt = BigInt('-12345678901234567890');
    const serialized = await dehydrateWorkflowArguments(
      bigInt,
      mockRunId,
      noEncryptionKey,
      []
    );
    expect(serialized).toMatchInlineSnapshot(`
      Uint8Array [
        100,
        101,
        118,
        108,
        91,
        91,
        34,
        66,
        105,
        103,
        73,
        110,
        116,
        34,
        44,
        49,
        93,
        44,
        34,
        45,
        49,
        50,
        51,
        52,
        53,
        54,
        55,
        56,
        57,
        48,
        49,
        50,
        51,
        52,
        53,
        54,
        55,
        56,
        57,
        48,
        34,
        93,
      ]
    `);

    const hydrated = await hydrateWorkflowArguments(
      serialized,
      mockRunId,
      noEncryptionKey,
      vmGlobalThis
    );
    expect(hydrated).toBe(BigInt('-12345678901234567890'));
    expect(typeof hydrated).toBe('bigint');
  });

  it('should work with Map', async () => {
    const map = new Map([
      [2, 'foo'],
      [6, 'bar'],
    ]);
    const serialized = await dehydrateWorkflowArguments(
      map,
      mockRunId,
      noEncryptionKey,
      []
    );
    expect(serialized).toMatchInlineSnapshot(`
      Uint8Array [
        100,
        101,
        118,
        108,
        91,
        91,
        34,
        77,
        97,
        112,
        34,
        44,
        49,
        93,
        44,
        91,
        50,
        44,
        53,
        93,
        44,
        91,
        51,
        44,
        52,
        93,
        44,
        50,
        44,
        34,
        102,
        111,
        111,
        34,
        44,
        91,
        54,
        44,
        55,
        93,
        44,
        54,
        44,
        34,
        98,
        97,
        114,
        34,
        93,
      ]
    `);

    const hydrated = await hydrateWorkflowArguments(
      serialized,
      mockRunId,
      noEncryptionKey,
      vmGlobalThis
    );
    vmGlobalThis.val = hydrated;

    expect(runInContext('val instanceof Map', context)).toBe(true);
  });

  it('should work with Set', async () => {
    const set = new Set([1, '2', true]);
    const serialized = await dehydrateWorkflowArguments(
      set,
      mockRunId,
      noEncryptionKey,
      []
    );
    expect(serialized).toMatchInlineSnapshot(`
      Uint8Array [
        100,
        101,
        118,
        108,
        91,
        91,
        34,
        83,
        101,
        116,
        34,
        44,
        49,
        93,
        44,
        91,
        50,
        44,
        51,
        44,
        52,
        93,
        44,
        49,
        44,
        34,
        50,
        34,
        44,
        116,
        114,
        117,
        101,
        93,
      ]
    `);

    const hydrated = await hydrateWorkflowArguments(
      serialized,
      mockRunId,
      noEncryptionKey,
      vmGlobalThis
    );
    vmGlobalThis.val = hydrated;

    expect(runInContext('val instanceof Set', context)).toBe(true);
  });

  it('should work with WritableStream', async () => {
    const stream = new WritableStream();
    const serialized = await dehydrateWorkflowArguments(
      stream,
      mockRunId,
      noEncryptionKey,
      []
    );
    expect(serialized instanceof Uint8Array).toBe(true);
    // Verify the serialized data contains WritableStream reference
    const serializedStr = new TextDecoder().decode(serialized);
    expect(serializedStr).toContain('WritableStream');

    class OurWritableStream {}
    const hydrated = await hydrateWorkflowArguments(
      serialized,
      mockRunId,
      noEncryptionKey,
      {
        WritableStream: OurWritableStream,
      }
    );
    expect(hydrated).toBeInstanceOf(OurWritableStream);
    const streamName = hydrated[STREAM_NAME_SYMBOL];
    expect(streamName).toMatch(/^strm_[0-9A-Z]{26}$/);
  });

  it('should work with ReadableStream', async () => {
    const stream = new ReadableStream();
    const serialized = await dehydrateWorkflowArguments(
      stream,
      mockRunId,
      noEncryptionKey,
      []
    );
    expect(serialized instanceof Uint8Array).toBe(true);
    // Verify the serialized data contains ReadableStream reference
    const serializedStr = new TextDecoder().decode(serialized);
    expect(serializedStr).toContain('ReadableStream');

    class OurReadableStream {}
    const hydrated = await hydrateWorkflowArguments(
      serialized,
      mockRunId,
      noEncryptionKey,
      {
        ReadableStream: OurReadableStream,
      }
    );
    expect(hydrated).toBeInstanceOf(OurReadableStream);
    const streamName = hydrated[STREAM_NAME_SYMBOL];
    expect(streamName).toMatch(/^strm_[0-9A-Z]{26}$/);
  });

  it('should work with Headers', async () => {
    const headers = new Headers();
    headers.set('foo', 'bar');
    headers.append('set-cookie', 'a');
    headers.append('set-cookie', 'b');
    const serialized = await dehydrateWorkflowArguments(
      headers,
      mockRunId,
      noEncryptionKey,
      []
    );
    expect(serialized).toMatchInlineSnapshot(`
      Uint8Array [
        100,
        101,
        118,
        108,
        91,
        91,
        34,
        72,
        101,
        97,
        100,
        101,
        114,
        115,
        34,
        44,
        49,
        93,
        44,
        91,
        50,
        44,
        53,
        44,
        56,
        93,
        44,
        91,
        51,
        44,
        52,
        93,
        44,
        34,
        102,
        111,
        111,
        34,
        44,
        34,
        98,
        97,
        114,
        34,
        44,
        91,
        54,
        44,
        55,
        93,
        44,
        34,
        115,
        101,
        116,
        45,
        99,
        111,
        111,
        107,
        105,
        101,
        34,
        44,
        34,
        97,
        34,
        44,
        91,
        54,
        44,
        57,
        93,
        44,
        34,
        98,
        34,
        93,
      ]
    `);

    const hydrated = await hydrateWorkflowArguments(
      serialized,
      mockRunId,
      noEncryptionKey,
      vmGlobalThis
    );
    expect(hydrated).toBeInstanceOf(Headers);
    expect(hydrated.get('foo')).toEqual('bar');
    expect(hydrated.get('set-cookie')).toEqual('a, b');
  });

  it('should work with Response', async () => {
    const response = new Response('Hello, world!', {
      status: 202,
      statusText: 'Custom',
      headers: new Headers([
        ['foo', 'bar'],
        ['set-cookie', 'a'],
        ['set-cookie', 'b'],
      ]),
    });
    const serialized = await dehydrateWorkflowArguments(
      response,
      mockRunId,
      noEncryptionKey,
      []
    );
    expect(serialized instanceof Uint8Array).toBe(true);
    // Verify the serialized data contains Response reference
    const serializedStr = new TextDecoder().decode(serialized);
    expect(serializedStr).toContain('Response');
    expect(serializedStr).toContain('ReadableStream');

    class OurResponse {
      public headers;
      public body;
      constructor(body, init) {
        this.body = body || init.body;
        this.headers = init.headers;
      }
    }
    class OurReadableStream {}
    class OurHeaders {}
    const hydrated = await hydrateWorkflowArguments(
      serialized,
      mockRunId,
      noEncryptionKey,
      {
        Headers: OurHeaders,
        Response: OurResponse,
        ReadableStream: OurReadableStream,
      }
    );
    expect(hydrated).toBeInstanceOf(OurResponse);
    expect(hydrated.headers).toBeInstanceOf(OurHeaders);
    expect(hydrated.body).toBeInstanceOf(OurReadableStream);
    // Verify stream name is generated correctly
    const bodyStreamName = hydrated.body[STREAM_NAME_SYMBOL];
    expect(bodyStreamName).toMatch(/^strm_[0-9A-Z]{26}$/);
  });

  it('should work with URLSearchParams', async () => {
    const params = new URLSearchParams('a=1&b=2&a=3');

    const serialized = await dehydrateWorkflowArguments(
      params,
      mockRunId,
      noEncryptionKey,
      []
    );
    expect(serialized).toMatchInlineSnapshot(`
      Uint8Array [
        100,
        101,
        118,
        108,
        91,
        91,
        34,
        85,
        82,
        76,
        83,
        101,
        97,
        114,
        99,
        104,
        80,
        97,
        114,
        97,
        109,
        115,
        34,
        44,
        49,
        93,
        44,
        34,
        97,
        61,
        49,
        38,
        98,
        61,
        50,
        38,
        97,
        61,
        51,
        34,
        93,
      ]
    `);

    const hydrated = await hydrateWorkflowArguments(
      serialized,
      mockRunId,
      noEncryptionKey,
      vmGlobalThis
    );
    vmGlobalThis.val = hydrated;
    expect(runInContext('val instanceof URLSearchParams', context)).toBe(true);
    expect(hydrated.getAll('a')).toEqual(['1', '3']);
    expect(hydrated.getAll('b')).toEqual(['2']);
    expect(hydrated.toString()).toEqual('a=1&b=2&a=3');
    expect(Array.from(hydrated.entries())).toEqual([
      ['a', '1'],
      ['b', '2'],
      ['a', '3'],
    ]);
  });

  it('should work with empty URLSearchParams', async () => {
    const params = new URLSearchParams();

    const serialized = await dehydrateWorkflowArguments(
      params,
      mockRunId,
      noEncryptionKey,
      []
    );
    expect(serialized).toMatchInlineSnapshot(`
      Uint8Array [
        100,
        101,
        118,
        108,
        91,
        91,
        34,
        85,
        82,
        76,
        83,
        101,
        97,
        114,
        99,
        104,
        80,
        97,
        114,
        97,
        109,
        115,
        34,
        44,
        49,
        93,
        44,
        34,
        46,
        34,
        93,
      ]
    `);

    const hydrated = await hydrateWorkflowArguments(
      serialized,
      mockRunId,
      noEncryptionKey,
      vmGlobalThis
    );
    vmGlobalThis.val = hydrated;
    expect(runInContext('val instanceof URLSearchParams', context)).toBe(true);
    expect(hydrated.toString()).toEqual('');
    expect(Array.from(hydrated.entries())).toEqual([]);
  });

  it('should work with empty ArrayBuffer', async () => {
    const buffer = new ArrayBuffer(0);

    const serialized = await dehydrateWorkflowArguments(
      buffer,
      mockRunId,
      noEncryptionKey,
      []
    );
    expect(serialized).toMatchInlineSnapshot(`
      Uint8Array [
        100,
        101,
        118,
        108,
        91,
        91,
        34,
        65,
        114,
        114,
        97,
        121,
        66,
        117,
        102,
        102,
        101,
        114,
        34,
        44,
        49,
        93,
        44,
        34,
        46,
        34,
        93,
      ]
    `);

    const hydrated = await hydrateWorkflowArguments(
      serialized,
      mockRunId,
      noEncryptionKey,
      vmGlobalThis
    );
    vmGlobalThis.val = hydrated;
    expect(runInContext('val instanceof ArrayBuffer', context)).toBe(true);
    expect(hydrated.byteLength).toEqual(0);
  });

  it('should work with empty Uint8Array', async () => {
    const array = new Uint8Array(0);

    const serialized = await dehydrateWorkflowArguments(
      array,
      mockRunId,
      noEncryptionKey,
      []
    );
    expect(serialized).toMatchInlineSnapshot(`
      Uint8Array [
        100,
        101,
        118,
        108,
        91,
        91,
        34,
        85,
        105,
        110,
        116,
        56,
        65,
        114,
        114,
        97,
        121,
        34,
        44,
        49,
        93,
        44,
        34,
        46,
        34,
        93,
      ]
    `);

    const hydrated = await hydrateWorkflowArguments(
      serialized,
      mockRunId,
      noEncryptionKey,
      vmGlobalThis
    );
    vmGlobalThis.val = hydrated;
    expect(runInContext('val instanceof Uint8Array', context)).toBe(true);
    expect(hydrated.length).toEqual(0);
    expect(hydrated.byteLength).toEqual(0);
  });

  it('should work with empty Int32Array', async () => {
    const array = new Int32Array(0);

    const serialized = await dehydrateWorkflowArguments(
      array,
      mockRunId,
      noEncryptionKey,
      []
    );
    expect(serialized).toMatchInlineSnapshot(`
      Uint8Array [
        100,
        101,
        118,
        108,
        91,
        91,
        34,
        73,
        110,
        116,
        51,
        50,
        65,
        114,
        114,
        97,
        121,
        34,
        44,
        49,
        93,
        44,
        34,
        46,
        34,
        93,
      ]
    `);

    const hydrated = await hydrateWorkflowArguments(
      serialized,
      mockRunId,
      noEncryptionKey,
      vmGlobalThis
    );
    vmGlobalThis.val = hydrated;
    expect(runInContext('val instanceof Int32Array', context)).toBe(true);
    expect(hydrated.length).toEqual(0);
    expect(hydrated.byteLength).toEqual(0);
  });

  it('should work with empty Float64Array', async () => {
    const array = new Float64Array(0);

    const serialized = await dehydrateWorkflowArguments(
      array,
      mockRunId,
      noEncryptionKey,
      []
    );
    expect(serialized).toMatchInlineSnapshot(`
      Uint8Array [
        100,
        101,
        118,
        108,
        91,
        91,
        34,
        70,
        108,
        111,
        97,
        116,
        54,
        52,
        65,
        114,
        114,
        97,
        121,
        34,
        44,
        49,
        93,
        44,
        34,
        46,
        34,
        93,
      ]
    `);

    const hydrated = await hydrateWorkflowArguments(
      serialized,
      mockRunId,
      noEncryptionKey,
      vmGlobalThis
    );
    vmGlobalThis.val = hydrated;
    expect(runInContext('val instanceof Float64Array', context)).toBe(true);
    expect(hydrated.length).toEqual(0);
    expect(hydrated.byteLength).toEqual(0);
  });

  it('should work with Request (without responseWritable)', async () => {
    // Mock STABLE_ULID to return a deterministic value
    const originalStableUlid = (globalThis as any)[STABLE_ULID];
    (globalThis as any)[STABLE_ULID] = () => '01ARZ3NDEKTSV4RRFFQ69G5FA1';

    try {
      const request = new Request('https://example.com/api', {
        method: 'POST',
        headers: new Headers([
          ['content-type', 'application/json'],
          ['x-custom', 'value'],
        ]),
        body: 'Hello, world!',
        duplex: 'half',
      } as RequestInit);

      const serialized = await dehydrateWorkflowArguments(
        request,
        mockRunId,
        noEncryptionKey,
        []
      );
      expect(serialized).toMatchInlineSnapshot(`
        Uint8Array [
          100,
          101,
          118,
          108,
          91,
          91,
          34,
          82,
          101,
          113,
          117,
          101,
          115,
          116,
          34,
          44,
          49,
          93,
          44,
          123,
          34,
          109,
          101,
          116,
          104,
          111,
          100,
          34,
          58,
          50,
          44,
          34,
          117,
          114,
          108,
          34,
          58,
          51,
          44,
          34,
          104,
          101,
          97,
          100,
          101,
          114,
          115,
          34,
          58,
          52,
          44,
          34,
          98,
          111,
          100,
          121,
          34,
          58,
          49,
          50,
          44,
          34,
          100,
          117,
          112,
          108,
          101,
          120,
          34,
          58,
          49,
          54,
          125,
          44,
          34,
          80,
          79,
          83,
          84,
          34,
          44,
          34,
          104,
          116,
          116,
          112,
          115,
          58,
          47,
          47,
          101,
          120,
          97,
          109,
          112,
          108,
          101,
          46,
          99,
          111,
          109,
          47,
          97,
          112,
          105,
          34,
          44,
          91,
          34,
          72,
          101,
          97,
          100,
          101,
          114,
          115,
          34,
          44,
          53,
          93,
          44,
          91,
          54,
          44,
          57,
          93,
          44,
          91,
          55,
          44,
          56,
          93,
          44,
          34,
          99,
          111,
          110,
          116,
          101,
          110,
          116,
          45,
          116,
          121,
          112,
          101,
          34,
          44,
          34,
          97,
          112,
          112,
          108,
          105,
          99,
          97,
          116,
          105,
          111,
          110,
          47,
          106,
          115,
          111,
          110,
          34,
          44,
          91,
          49,
          48,
          44,
          49,
          49,
          93,
          44,
          34,
          120,
          45,
          99,
          117,
          115,
          116,
          111,
          109,
          34,
          44,
          34,
          118,
          97,
          108,
          117,
          101,
          34,
          44,
          91,
          34,
          82,
          101,
          97,
          100,
          97,
          98,
          108,
          101,
          83,
          116,
          114,
          101,
          97,
          109,
          34,
          44,
          49,
          51,
          93,
          44,
          123,
          34,
          110,
          97,
          109,
          101,
          34,
          58,
          49,
          52,
          44,
          34,
          116,
          121,
          112,
          101,
          34,
          58,
          49,
          53,
          125,
          44,
          34,
          115,
          116,
          114,
          109,
          95,
          48,
          49,
          65,
          82,
          90,
          51,
          78,
          68,
          69,
          75,
          84,
          83,
          86,
          52,
          82,
          82,
          70,
          70,
          81,
          54,
          57,
          71,
          53,
          70,
          65,
          49,
          34,
          44,
          34,
          98,
          121,
          116,
          101,
          115,
          34,
          44,
          34,
          104,
          97,
          108,
          102,
          34,
          93,
        ]
      `);

      class OurRequest {
        public method;
        public url;
        public headers;
        public body;
        public duplex;
        constructor(url, init) {
          this.method = init.method;
          this.url = url;
          this.headers = init.headers;
          this.body = init.body;
          this.duplex = init.duplex;
        }
      }
      class OurReadableStream {}
      class OurHeaders {}
      const hydrated = await hydrateWorkflowArguments(
        serialized,
        mockRunId,
        noEncryptionKey,
        {
          Request: OurRequest,
          Headers: OurHeaders,
          ReadableStream: OurReadableStream,
        }
      );
      expect(hydrated).toBeInstanceOf(OurRequest);
      expect(hydrated.method).toBe('POST');
      expect(hydrated.url).toBe('https://example.com/api');
      expect(hydrated.headers).toBeInstanceOf(OurHeaders);
      expect(hydrated.body).toBeInstanceOf(OurReadableStream);
      expect(hydrated.duplex).toBe('half');
    } finally {
      (globalThis as any)[STABLE_ULID] = originalStableUlid;
    }
  });

  it('should work with Request (with responseWritable)', async () => {
    // Mock STABLE_ULID to return deterministic values
    const originalStableUlid = (globalThis as any)[STABLE_ULID];
    let ulidCounter = 0;
    (globalThis as any)[STABLE_ULID] = () => {
      const ulids = [
        '01ARZ3NDEKTSV4RRFFQ69G5FA1',
        '01ARZ3NDEKTSV4RRFFQ69G5FA2',
      ] as const;
      return ulids[ulidCounter++];
    };

    try {
      const request = new Request('https://example.com/webhook', {
        method: 'POST',
        headers: new Headers({ 'content-type': 'application/json' }),
        body: 'webhook payload',
        duplex: 'half',
      } as RequestInit);

      // Simulate webhook behavior by attaching a responseWritable stream
      const responseWritable = new WritableStream();
      request[Symbol.for('WEBHOOK_RESPONSE_WRITABLE')] = responseWritable;

      const serialized = await dehydrateWorkflowArguments(
        request,
        mockRunId,
        noEncryptionKey,
        []
      );
      expect(serialized).toMatchInlineSnapshot(`
        Uint8Array [
          100,
          101,
          118,
          108,
          91,
          91,
          34,
          82,
          101,
          113,
          117,
          101,
          115,
          116,
          34,
          44,
          49,
          93,
          44,
          123,
          34,
          109,
          101,
          116,
          104,
          111,
          100,
          34,
          58,
          50,
          44,
          34,
          117,
          114,
          108,
          34,
          58,
          51,
          44,
          34,
          104,
          101,
          97,
          100,
          101,
          114,
          115,
          34,
          58,
          52,
          44,
          34,
          98,
          111,
          100,
          121,
          34,
          58,
          57,
          44,
          34,
          100,
          117,
          112,
          108,
          101,
          120,
          34,
          58,
          49,
          51,
          44,
          34,
          114,
          101,
          115,
          112,
          111,
          110,
          115,
          101,
          87,
          114,
          105,
          116,
          97,
          98,
          108,
          101,
          34,
          58,
          49,
          52,
          125,
          44,
          34,
          80,
          79,
          83,
          84,
          34,
          44,
          34,
          104,
          116,
          116,
          112,
          115,
          58,
          47,
          47,
          101,
          120,
          97,
          109,
          112,
          108,
          101,
          46,
          99,
          111,
          109,
          47,
          119,
          101,
          98,
          104,
          111,
          111,
          107,
          34,
          44,
          91,
          34,
          72,
          101,
          97,
          100,
          101,
          114,
          115,
          34,
          44,
          53,
          93,
          44,
          91,
          54,
          93,
          44,
          91,
          55,
          44,
          56,
          93,
          44,
          34,
          99,
          111,
          110,
          116,
          101,
          110,
          116,
          45,
          116,
          121,
          112,
          101,
          34,
          44,
          34,
          97,
          112,
          112,
          108,
          105,
          99,
          97,
          116,
          105,
          111,
          110,
          47,
          106,
          115,
          111,
          110,
          34,
          44,
          91,
          34,
          82,
          101,
          97,
          100,
          97,
          98,
          108,
          101,
          83,
          116,
          114,
          101,
          97,
          109,
          34,
          44,
          49,
          48,
          93,
          44,
          123,
          34,
          110,
          97,
          109,
          101,
          34,
          58,
          49,
          49,
          44,
          34,
          116,
          121,
          112,
          101,
          34,
          58,
          49,
          50,
          125,
          44,
          34,
          115,
          116,
          114,
          109,
          95,
          48,
          49,
          65,
          82,
          90,
          51,
          78,
          68,
          69,
          75,
          84,
          83,
          86,
          52,
          82,
          82,
          70,
          70,
          81,
          54,
          57,
          71,
          53,
          70,
          65,
          49,
          34,
          44,
          34,
          98,
          121,
          116,
          101,
          115,
          34,
          44,
          34,
          104,
          97,
          108,
          102,
          34,
          44,
          91,
          34,
          87,
          114,
          105,
          116,
          97,
          98,
          108,
          101,
          83,
          116,
          114,
          101,
          97,
          109,
          34,
          44,
          49,
          53,
          93,
          44,
          123,
          34,
          110,
          97,
          109,
          101,
          34,
          58,
          49,
          54,
          125,
          44,
          34,
          115,
          116,
          114,
          109,
          95,
          48,
          49,
          65,
          82,
          90,
          51,
          78,
          68,
          69,
          75,
          84,
          83,
          86,
          52,
          82,
          82,
          70,
          70,
          81,
          54,
          57,
          71,
          53,
          70,
          65,
          50,
          34,
          93,
        ]
      `);

      class OurRequest {
        public method;
        public url;
        public headers;
        public body;
        public duplex;
        public responseWritable;
        public respondWith;
        constructor(url, init) {
          this.method = init.method;
          this.url = url;
          this.headers = init.headers;
          this.body = init.body;
          this.duplex = init.duplex;
        }
      }
      class OurReadableStream {}
      class OurWritableStream {}
      class OurHeaders {}
      const hydrated = await hydrateWorkflowArguments(
        serialized,
        mockRunId,
        noEncryptionKey,
        {
          Request: OurRequest,
          Headers: OurHeaders,
          ReadableStream: OurReadableStream,
          WritableStream: OurWritableStream,
        }
      );
      expect(hydrated).toBeInstanceOf(OurRequest);
      expect(hydrated.method).toBe('POST');
      expect(hydrated.url).toBe('https://example.com/webhook');
      expect(hydrated.headers).toBeInstanceOf(OurHeaders);
      expect(hydrated.body).toBeInstanceOf(OurReadableStream);
      expect(hydrated.duplex).toBe('half');
      // responseWritable should be moved to the symbol
      expect(hydrated.responseWritable).toBeUndefined();
      expect(hydrated[Symbol.for('WEBHOOK_RESPONSE_WRITABLE')]).toBeInstanceOf(
        OurWritableStream
      );
      // respondWith should throw an error when called from workflow context
      expect(hydrated.respondWith).toBeInstanceOf(Function);
      expect(() => hydrated.respondWith()).toThrow(
        '`respondWith()` must be called from within a step function'
      );
    } finally {
      (globalThis as any)[STABLE_ULID] = originalStableUlid;
    }
  });

  it('should throw error for an unsupported type', async () => {
    class Foo {}
    let err: WorkflowRuntimeError | undefined;
    try {
      await dehydrateWorkflowArguments(
        new Foo(),
        mockRunId,
        noEncryptionKey,
        []
      );
    } catch (err_) {
      err = err_ as WorkflowRuntimeError;
    }
    expect(err).toBeDefined();
    expect(err?.message).toContain(
      `Ensure you're passing serializable types (plain objects, arrays, primitives, Date, RegExp, Map, Set).`
    );
  });
});

describe('workflow return value', () => {
  it('should throw error for an unsupported type', async () => {
    class Foo {}
    let err: WorkflowRuntimeError | undefined;
    try {
      await dehydrateWorkflowReturnValue(new Foo(), mockRunId, noEncryptionKey);
    } catch (err_) {
      err = err_ as WorkflowRuntimeError;
    }
    expect(err).toBeDefined();
    expect(err?.message).toContain(
      `Ensure you're returning serializable types (plain objects, arrays, primitives, Date, RegExp, Map, Set).`
    );
  });
});

describe('step arguments', () => {
  it('should throw error for an unsupported type', async () => {
    class Foo {}
    let err: WorkflowRuntimeError | undefined;
    try {
      await dehydrateStepArguments(
        new Foo(),
        mockRunId,
        noEncryptionKey,
        globalThis
      );
    } catch (err_) {
      err = err_ as WorkflowRuntimeError;
    }
    expect(err).toBeDefined();
    expect(err?.message).toContain(
      `Ensure you're passing serializable types (plain objects, arrays, primitives, Date, RegExp, Map, Set).`
    );
  });
});

describe('cross-VM Error serialization', () => {
  // Create a VM context that mimics the real workflow VM setup (with
  // Request/Response/ReadableStream/WritableStream from the host context)
  const { context, globalThis: vmGlobalThis } = createContext({
    seed: 'test-error',
    fixedTimestamp: 1714857600000,
  });
  // The real workflow VM (workflow.ts) sets these on vmGlobalThis.
  // Without them, other reducers would throw on `instanceof` checks.
  vmGlobalThis.Request = globalThis.Request;
  vmGlobalThis.Response = globalThis.Response;
  vmGlobalThis.ReadableStream = globalThis.ReadableStream;
  vmGlobalThis.WritableStream = globalThis.WritableStream;

  it('should serialize a host-context Error when using VM globalThis', async () => {
    // This simulates the scenario where a FatalError (created in the host
    // context) is passed as an argument to a step function. The serialization
    // uses VM's globalThis, so `instanceof vmGlobal.Error` would fail for
    // host-context errors. Using types.isNativeError() fixes this.
    const hostError = new Error('host error');
    hostError.name = 'FatalError';

    const serialized = await dehydrateStepArguments(
      [hostError],
      mockRunId,
      noEncryptionKey,
      vmGlobalThis
    );

    const ops: Promise<void>[] = [];
    const hydrated = await hydrateStepArguments(
      serialized,
      mockRunId,
      noEncryptionKey,
      ops,
      vmGlobalThis
    );

    // The reviver creates errors with `new global.Error()` (VM's Error),
    // so `instanceof` against the host Error fails. Check duck-type instead.
    expect((hydrated[0] as Error).name).toBe('FatalError');
    expect((hydrated[0] as Error).message).toBe('host error');
    // Verify it's an instance of the VM's Error
    vmGlobalThis.__testVal = hydrated[0];
    expect(runInContext('__testVal instanceof Error', context)).toBe(true);
  });

  it('should serialize a VM-context Error when using VM globalThis', async () => {
    const vmError = runInContext(
      '(() => { const e = new Error("vm error"); e.name = "FatalError"; return e; })()',
      context
    );

    const serialized = await dehydrateStepArguments(
      [vmError],
      mockRunId,
      noEncryptionKey,
      vmGlobalThis
    );

    const ops: Promise<void>[] = [];
    const hydrated = await hydrateStepArguments(
      serialized,
      mockRunId,
      noEncryptionKey,
      ops,
      vmGlobalThis
    );

    // The reviver creates errors with `new global.Error()` (VM's Error),
    // so `instanceof` against the host Error fails. Check duck-type instead.
    expect((hydrated[0] as Error).name).toBe('FatalError');
    expect((hydrated[0] as Error).message).toBe('vm error');
    // Verify it's an instance of the VM's Error
    vmGlobalThis.__testVal = hydrated[0];
    expect(runInContext('__testVal instanceof Error', context)).toBe(true);
  });

  it('should serialize Error subclass from host context through workflow reducers', async () => {
    class FatalError extends Error {
      constructor(message: string) {
        super(message);
        this.name = 'FatalError';
      }
    }
    const error = new FatalError('step failed');

    const serialized = await dehydrateStepArguments(
      { error },
      mockRunId,
      noEncryptionKey,
      vmGlobalThis
    );

    const ops: Promise<void>[] = [];
    const hydrated = (await hydrateStepArguments(
      serialized,
      mockRunId,
      noEncryptionKey,
      ops,
      vmGlobalThis
    )) as { error: Error };

    // The reviver creates errors with `new global.Error()` (VM's Error)
    expect(hydrated.error.name).toBe('FatalError');
    expect(hydrated.error.message).toBe('step failed');
    // Verify it's an instance of the VM's Error
    vmGlobalThis.__testVal = hydrated.error;
    expect(runInContext('__testVal instanceof Error', context)).toBe(true);
  });
});

describe('step return value', () => {
  it('should throw error for an unsupported type', async () => {
    class Foo {}
    let err: WorkflowRuntimeError | undefined;
    try {
      await dehydrateStepReturnValue(new Foo(), mockRunId, noEncryptionKey, []);
    } catch (err_) {
      err = err_ as WorkflowRuntimeError;
    }

    expect(err).toBeDefined();
    expect(err?.message).toContain(
      `Ensure you're returning serializable types (plain objects, arrays, primitives, Date, RegExp, Map, Set).`
    );
  });
});

describe('step function serialization', () => {
  const { globalThis: vmGlobalThis } = createContext({
    seed: 'test',
    fixedTimestamp: 1714857600000,
  });

  it('should detect step function by checking for stepId property', () => {
    const stepName = 'myStep';
    const stepFn = async (x: number) => x * 2;

    // Attach stepId like useStep() does
    Object.defineProperty(stepFn, 'stepId', {
      value: stepName,
      writable: false,
      enumerable: false,
      configurable: false,
    });

    // Verify the property is attached correctly
    expect((stepFn as any).stepId).toBe(stepName);
  });

  it('should not have stepId on regular functions', () => {
    const regularFn = async (x: number) => x * 2;

    // Regular functions should not have stepId
    expect((regularFn as any).stepId).toBeUndefined();
  });

  it('should lookup registered step function by name', () => {
    const stepName = 'myRegisteredStep';
    const stepFn = async (x: number) => x * 2;

    // Register the step function
    registerStepFunction(stepName, stepFn);

    // Should be retrievable by name
    const retrieved = getStepFunction(stepName);
    expect(retrieved).toBe(stepFn);
  });

  it('should return undefined for non-existent registered step function', () => {
    const retrieved = getStepFunction('nonExistentStep');
    expect(retrieved).toBeUndefined();
  });

  it('should lookup builtin response step by bare ID alias', () => {
    const registeredStepId =
      'step//workflow/internal/builtins@4.2.0-beta.71//__builtin_response_text';
    const stepFn = async () => 'ok';

    registerStepFunction(registeredStepId, stepFn);

    const retrieved = getStepFunction('__builtin_response_text');
    expect(retrieved).toBe(stepFn);
  });

  it('should deserialize step function name through reviver', async () => {
    const stepName = 'step//test//testStep';
    const stepFn = async () => 42;

    // Register the step function
    registerStepFunction(stepName, stepFn);

    // Create a function with stepId property (like registerStepFunction does)
    const fnWithStepId = async () => 42;
    Object.defineProperty(fnWithStepId, 'stepId', {
      value: stepName,
      writable: false,
      enumerable: false,
      configurable: false,
    });

    // Serialize using workflow reducers (which handle StepFunction)
    const dehydrated = await dehydrateStepArguments(
      [fnWithStepId],
      mockRunId,
      noEncryptionKey,
      globalThis
    );

    // Hydrate it back using step revivers
    const ops: Promise<void>[] = [];
    const hydrated = await hydrateStepArguments(
      dehydrated,
      mockRunId,
      noEncryptionKey,
      ops,
      globalThis
    );

    // The hydrated result should be the registered step function
    expect(hydrated[0]).toBe(stepFn);
  });

  it('should deserialize step function using workflows/example path aliases', async () => {
    const registeredStepId = 'step//./example/workflows/99_e2e//doubleNumber';
    const aliasedStepId = 'step//./workflows/99_e2e//doubleNumber';
    const stepFn = async () => 42;

    registerStepFunction(registeredStepId, stepFn);

    const fnWithStepId = async () => 42;
    Object.defineProperty(fnWithStepId, 'stepId', {
      value: aliasedStepId,
      writable: false,
      enumerable: false,
      configurable: false,
    });
    const dehydrated = await dehydrateStepArguments(
      [fnWithStepId],
      mockRunId,
      undefined,
      globalThis
    );
    const hydrated = await hydrateStepArguments(
      dehydrated,
      mockRunId,
      undefined,
      [],
      globalThis
    );
    const result = hydrated[0];

    expect(result).toBe(stepFn);
  });

  it('should deserialize step function using workflows/src path aliases', async () => {
    const registeredStepId = 'step//./src/workflows/99_e2e//doubleFromSrc';
    const aliasedStepId = 'step//./workflows/99_e2e//doubleFromSrc';
    const stepFn = async () => 42;

    registerStepFunction(registeredStepId, stepFn);

    const fnWithStepId = async () => 42;
    Object.defineProperty(fnWithStepId, 'stepId', {
      value: aliasedStepId,
      writable: false,
      enumerable: false,
      configurable: false,
    });
    const dehydrated = await dehydrateStepArguments(
      [fnWithStepId],
      mockRunId,
      undefined,
      globalThis
    );
    const hydrated = await hydrateStepArguments(
      dehydrated,
      mockRunId,
      undefined,
      [],
      globalThis
    );
    const result = hydrated[0];

    expect(result).toBe(stepFn);
  });

  it('should throw error when reviver cannot find registered step function', async () => {
    // Create a function with a non-existent stepId
    const fnWithNonExistentStepId = async () => 42;
    Object.defineProperty(fnWithNonExistentStepId, 'stepId', {
      value: 'nonExistentStep',
      writable: false,
      enumerable: false,
      configurable: false,
    });

    // Serialize the step function reference
    const dehydrated = await dehydrateStepArguments(
      [fnWithNonExistentStepId],
      mockRunId,
      noEncryptionKey,
      globalThis
    );

    // Hydrating should throw an error
    const ops: Promise<void>[] = [];
    let err: Error | undefined;
    try {
      await hydrateStepArguments(
        dehydrated,
        mockRunId,
        noEncryptionKey,
        ops,
        globalThis
      );
    } catch (err_) {
      err = err_ as Error;
    }

    expect(err).toBeDefined();
    expect(err?.message).toContain('Step function "nonExistentStep" not found');
    expect(err?.message).toContain('Make sure the step function is registered');
  });

  it('should dehydrate step function passed as argument to a step', async () => {
    const stepName = 'step//workflows/test.ts//myStep';
    const stepFn = async (x: number) => x * 2;

    // Register the step function
    registerStepFunction(stepName, stepFn);

    // Attach stepId to the function (like useStep() does)
    Object.defineProperty(stepFn, 'stepId', {
      value: stepName,
      writable: false,
      enumerable: false,
      configurable: false,
    });

    // Simulate passing a step function as an argument within a workflow
    // When calling a step from within a workflow context
    const args = [stepFn, 42];

    // This should serialize the step function by its name using the reducer
    const dehydrated = await dehydrateStepArguments(
      args,
      mockRunId,
      noEncryptionKey,
      globalThis
    );

    // Verify it dehydrated successfully
    expect(dehydrated).toBeDefined();
    expect(dehydrated instanceof Uint8Array).toBe(true);
    // The dehydrated structure is a binary format from devalue
    // It should contain the step function serialized as its name
    const dehydratedStr = new TextDecoder().decode(dehydrated);
    expect(dehydratedStr).toContain(stepName);
    expect(dehydratedStr).toContain('42');
  });

  it('should dehydrate and hydrate step function with closure variables', async () => {
    const stepName = 'step//workflows/test.ts//calculate';

    // Create a step function that accesses closure variables
    const { __private_getClosureVars } = await import('./private.js');
    const { contextStorage } = await import('./step/context-storage.js');

    const stepFn = async (x: number) => {
      const { multiplier, prefix } = __private_getClosureVars();
      const result = x * multiplier;
      return `${prefix}${result}`;
    };

    // Register the step function
    registerStepFunction(stepName, stepFn);

    // Simulate what useStep() does - attach stepId and closure vars function
    Object.defineProperty(stepFn, 'stepId', {
      value: stepName,
      writable: false,
      enumerable: false,
      configurable: false,
    });

    const closureVars = { multiplier: 3, prefix: 'Result: ' };
    Object.defineProperty(stepFn, '__closureVarsFn', {
      value: () => closureVars,
      writable: false,
      enumerable: false,
      configurable: false,
    });

    // Serialize the step function with closure variables
    const args = [stepFn, 7];
    const dehydrated = await dehydrateStepArguments(
      args,
      mockRunId,
      noEncryptionKey,
      globalThis
    );

    // Verify it serialized
    expect(dehydrated).toBeDefined();
    expect(dehydrated instanceof Uint8Array).toBe(true);
    const serialized = new TextDecoder().decode(dehydrated);
    expect(serialized).toContain(stepName);
    expect(serialized).toContain('multiplier');
    expect(serialized).toContain('prefix');

    // Now hydrate it back
    const hydrated = await hydrateStepArguments(
      dehydrated,
      'test-run-123',
      noEncryptionKey,
      [],
      vmGlobalThis
    );
    expect(Array.isArray(hydrated)).toBe(true);
    expect(hydrated).toHaveLength(2);

    const hydratedStepFn = hydrated[0];
    const hydratedArg = hydrated[1];

    expect(typeof hydratedStepFn).toBe('function');
    expect(hydratedArg).toBe(7);

    // Invoke the hydrated step function within a context
    const result = await contextStorage.run(
      {
        stepMetadata: {
          stepName: 'step//workflows/test.ts//addNumbers',
          stepId: 'test-step',
          stepStartedAt: new Date(),
          attempt: 1,
        },
        workflowMetadata: {
          workflowName: 'workflow//workflows/test.ts//testWorkflow',
          workflowRunId: 'test-run',
          workflowStartedAt: new Date(),
          url: 'http://localhost:3000',
        },
        ops: [],
      },
      () => hydratedStepFn(7)
    );

    // Verify the closure variables were accessible and used correctly
    expect(result).toBe('Result: 21');
  });

  it('should serialize step function to object through reducer', () => {
    const stepName = 'step//workflows/test.ts//anotherStep';
    const stepFn = async () => 'result';

    // Attach stepId to the function (like useStep() does)
    Object.defineProperty(stepFn, 'stepId', {
      value: stepName,
      writable: false,
      enumerable: false,
      configurable: false,
    });

    // Get the reducer and verify it detects the step function
    const reducer = getWorkflowReducers(globalThis).StepFunction;
    const result = reducer(stepFn);

    // Should return object with stepId
    expect(result).toEqual({ stepId: stepName });
  });

  it('should hydrate step function from workflow arguments using WORKFLOW_USE_STEP', async () => {
    // This tests the flow: client mode serializes step function with stepId,
    // workflow mode deserializes it using WORKFLOW_USE_STEP from vmGlobalThis
    const stepId = 'step//workflows/test.ts//addNumbers';

    // Create a VM context like the workflow runner does
    const { context, globalThis: vmGlobalThis } = createContext({
      seed: 'test',
      fixedTimestamp: 1714857600000,
    });

    // Set up WORKFLOW_USE_STEP on the VM's globalThis (like workflow.ts does)
    const mockUseStep = (id: string) => {
      const fn = (...args: any[]) => {
        // Return a promise that resolves with args (like useStep wrapper does)
        return Promise.resolve({ calledWithStepId: id, args });
      };
      fn.stepId = id;
      return fn;
    };
    (vmGlobalThis as any)[Symbol.for('WORKFLOW_USE_STEP')] = mockUseStep;

    // Create a function with stepId (like SWC plugin does in client mode)
    const clientStepFn = async (a: number, b: number) => a + b;
    Object.defineProperty(clientStepFn, 'stepId', {
      value: stepId,
      writable: false,
      enumerable: false,
      configurable: false,
    });

    // Serialize from client side using external reducers
    const ops: Promise<void>[] = [];
    const dehydrated = await dehydrateWorkflowArguments(
      [clientStepFn, 3, 5],
      mockRunId,
      noEncryptionKey,
      ops,
      globalThis
    );

    // Hydrate in workflow context using VM's globalThis
    const hydrated = await hydrateWorkflowArguments(
      dehydrated,
      mockRunId,
      noEncryptionKey,
      vmGlobalThis
    );

    // Verify the hydrated result
    expect(Array.isArray(hydrated)).toBe(true);
    expect(hydrated).toHaveLength(3);

    const [hydratedStepFn, arg1, arg2] = hydrated;

    // The step function should be a function (from useStep wrapper)
    expect(typeof hydratedStepFn).toBe('function');
    expect(arg1).toBe(3);
    expect(arg2).toBe(5);

    // The hydrated function should have stepId
    expect(hydratedStepFn.stepId).toBe(stepId);
  });

  it('should throw error when WORKFLOW_USE_STEP is not set on globalThis', async () => {
    const stepId = 'step//workflows/test.ts//missingUseStep';

    // Create a VM context WITHOUT setting up WORKFLOW_USE_STEP
    const { context, globalThis: vmGlobalThis } = createContext({
      seed: 'test',
      fixedTimestamp: 1714857600000,
    });

    // Create a function with stepId
    const clientStepFn = async (a: number, b: number) => a + b;
    Object.defineProperty(clientStepFn, 'stepId', {
      value: stepId,
      writable: false,
      enumerable: false,
      configurable: false,
    });

    // Serialize from client side
    const ops: Promise<void>[] = [];
    const dehydrated = await dehydrateWorkflowArguments(
      [clientStepFn],
      mockRunId,
      noEncryptionKey,
      ops,
      globalThis
    );

    // Hydrating should throw because WORKFLOW_USE_STEP is not set
    await expect(
      hydrateWorkflowArguments(
        dehydrated,
        mockRunId,
        noEncryptionKey,
        vmGlobalThis
      )
    ).rejects.toThrow('WORKFLOW_USE_STEP not found on global object');
  });
});

describe('custom class serialization', () => {
  const { context, globalThis: vmGlobalThis } = createContext({
    seed: 'test',
    fixedTimestamp: 1714857600000,
  });

  // Make the serialization symbols available inside the VM
  (vmGlobalThis as any).WORKFLOW_SERIALIZE = WORKFLOW_SERIALIZE;
  (vmGlobalThis as any).WORKFLOW_DESERIALIZE = WORKFLOW_DESERIALIZE;

  // Define registerSerializationClass inside the VM so that it uses the VM's globalThis.
  // In production, the workflow bundle includes the full function code, so globalThis
  // inside it refers to the VM's global. We simulate that here.
  runInContext(
    `
    const WORKFLOW_CLASS_REGISTRY = Symbol.for('workflow-class-registry');
    function registerSerializationClass(classId, cls) {
      let registry = globalThis[WORKFLOW_CLASS_REGISTRY];
      if (!registry) {
        registry = new Map();
        globalThis[WORKFLOW_CLASS_REGISTRY] = registry;
      }
      registry.set(classId, cls);
      Object.defineProperty(cls, 'classId', {
        value: classId,
        writable: false,
        enumerable: false,
        configurable: false,
      });
    }
    globalThis.registerSerializationClass = registerSerializationClass;
    `,
    context
  );

  it('should serialize and deserialize a class with WORKFLOW_SERIALIZE/DESERIALIZE', async () => {
    // Define the class in the host context (for serialization)
    class Point {
      constructor(
        public x: number,
        public y: number
      ) {}

      static [WORKFLOW_SERIALIZE](instance: Point) {
        return { x: instance.x, y: instance.y };
      }

      static [WORKFLOW_DESERIALIZE](data: { x: number; y: number }) {
        return new Point(data.x, data.y);
      }
    }

    // The classId is normally generated by the SWC compiler
    (Point as any).classId = 'test/Point';

    // Register the class on the host for serialization
    registerSerializationClass('test/Point', Point);

    // Define and register the class inside the VM (simulates workflow bundle)
    // In production, the SWC plugin generates this code in the workflow bundle
    runInContext(
      `
      class Point {
        constructor(x, y) {
          this.x = x;
          this.y = y;
        }
        static [WORKFLOW_SERIALIZE](instance) {
          return { x: instance.x, y: instance.y };
        }
        static [WORKFLOW_DESERIALIZE](data) {
          return new Point(data.x, data.y);
        }
      }
      Point.classId = 'test/Point';
      registerSerializationClass('test/Point', Point);
      `,
      context
    );

    const point = new Point(10, 20);
    const serialized = await dehydrateWorkflowArguments(
      point,
      mockRunId,
      noEncryptionKey,
      []
    );

    // Verify it serialized with the Instance type
    expect(serialized).toBeDefined();
    expect(serialized instanceof Uint8Array).toBe(true);
    // Check that the serialized data contains the classId
    const serializedStr = new TextDecoder().decode(serialized);
    expect(serializedStr).toContain('test/Point');

    // Hydrate it back (inside the VM context)
    const hydrated = await hydrateWorkflowArguments(
      serialized,
      mockRunId,
      noEncryptionKey,
      vmGlobalThis
    );
    // Note: hydrated is an instance of the VM's Point class, not the host's
    // so we check constructor.name instead of instanceof
    expect(hydrated.constructor.name).toBe('Point');
    expect(hydrated.x).toBe(10);
    expect(hydrated.y).toBe(20);
  });

  it('should serialize nested custom serializable objects', async () => {
    // Define the class in the host context (for serialization)
    class Vector {
      constructor(
        public dx: number,
        public dy: number
      ) {}

      static [WORKFLOW_SERIALIZE](instance: Vector) {
        return { dx: instance.dx, dy: instance.dy };
      }

      static [WORKFLOW_DESERIALIZE](data: { dx: number; dy: number }) {
        return new Vector(data.dx, data.dy);
      }
    }

    // The classId is normally generated by the SWC compiler
    (Vector as any).classId = 'test/Vector';

    // Register the class on the host for serialization
    registerSerializationClass('test/Vector', Vector);

    // Define and register the class inside the VM
    runInContext(
      `
      class Vector {
        constructor(dx, dy) {
          this.dx = dx;
          this.dy = dy;
        }
        static [WORKFLOW_SERIALIZE](instance) {
          return { dx: instance.dx, dy: instance.dy };
        }
        static [WORKFLOW_DESERIALIZE](data) {
          return new Vector(data.dx, data.dy);
        }
      }
      Vector.classId = 'test/Vector';
      registerSerializationClass('test/Vector', Vector);
      `,
      context
    );

    const data = {
      name: 'test',
      vector: new Vector(5, 10),
      nested: {
        anotherVector: new Vector(1, 2),
      },
    };

    const serialized = await dehydrateWorkflowArguments(
      data,
      mockRunId,
      noEncryptionKey,
      []
    );
    const hydrated = await hydrateWorkflowArguments(
      serialized,
      mockRunId,
      noEncryptionKey,
      vmGlobalThis
    );

    expect(hydrated.name).toBe('test');
    expect(hydrated.vector.constructor.name).toBe('Vector');
    expect(hydrated.vector.dx).toBe(5);
    expect(hydrated.vector.dy).toBe(10);
    expect(hydrated.nested.anotherVector.constructor.name).toBe('Vector');
    expect(hydrated.nested.anotherVector.dx).toBe(1);
    expect(hydrated.nested.anotherVector.dy).toBe(2);
  });

  it('should serialize custom class in an array', async () => {
    // Define the class in the host context (for serialization)
    class Item {
      constructor(public id: string) {}

      static [WORKFLOW_SERIALIZE](instance: Item) {
        return { id: instance.id };
      }

      static [WORKFLOW_DESERIALIZE](data: { id: string }) {
        return new Item(data.id);
      }
    }

    // The classId is normally generated by the SWC compiler
    (Item as any).classId = 'test/Item';

    // Register the class on the host for serialization
    registerSerializationClass('test/Item', Item);

    // Define and register the class inside the VM
    runInContext(
      `
      class Item {
        constructor(id) {
          this.id = id;
        }
        static [WORKFLOW_SERIALIZE](instance) {
          return { id: instance.id };
        }
        static [WORKFLOW_DESERIALIZE](data) {
          return new Item(data.id);
        }
      }
      Item.classId = 'test/Item';
      registerSerializationClass('test/Item', Item);
      `,
      context
    );

    const items = [new Item('a'), new Item('b'), new Item('c')];

    const serialized = await dehydrateWorkflowArguments(
      items,
      mockRunId,
      noEncryptionKey,
      []
    );
    const hydrated = await hydrateWorkflowArguments(
      serialized,
      mockRunId,
      noEncryptionKey,
      vmGlobalThis
    );

    expect(Array.isArray(hydrated)).toBe(true);
    expect(hydrated).toHaveLength(3);
    expect(hydrated[0].constructor.name).toBe('Item');
    expect(hydrated[0].id).toBe('a');
    expect(hydrated[1].constructor.name).toBe('Item');
    expect(hydrated[1].id).toBe('b');
    expect(hydrated[2].constructor.name).toBe('Item');
    expect(hydrated[2].id).toBe('c');
  });

  it('should work with step arguments', async () => {
    class Config {
      constructor(
        public setting: string,
        public value: number
      ) {}

      static [WORKFLOW_SERIALIZE](instance: Config) {
        return { setting: instance.setting, value: instance.value };
      }

      static [WORKFLOW_DESERIALIZE](data: { setting: string; value: number }) {
        return new Config(data.setting, data.value);
      }
    }

    // The classId is normally generated by the SWC compiler
    (Config as any).classId = 'test/Config';

    // Register the class for deserialization
    registerSerializationClass('test/Config', Config);

    const config = new Config('maxRetries', 3);
    const serialized = await dehydrateStepArguments(
      [config],
      mockRunId,
      noEncryptionKey,
      globalThis
    );
    const hydrated = await hydrateStepArguments(
      serialized,
      mockRunId,
      noEncryptionKey,
      [],
      globalThis
    );

    expect(Array.isArray(hydrated)).toBe(true);
    expect(hydrated[0]).toBeInstanceOf(Config);
    expect(hydrated[0].setting).toBe('maxRetries');
    expect(hydrated[0].value).toBe(3);
  });

  it('should work with step return values', async () => {
    class Result {
      constructor(
        public success: boolean,
        public data: string
      ) {}

      static [WORKFLOW_SERIALIZE](instance: Result) {
        return { success: instance.success, data: instance.data };
      }

      static [WORKFLOW_DESERIALIZE](data: { success: boolean; data: string }) {
        return new Result(data.success, data.data);
      }
    }

    // The classId is normally generated by the SWC compiler
    (Result as any).classId = 'test/Result';

    // Register the class for deserialization
    registerSerializationClass('test/Result', Result);

    const result = new Result(true, 'completed');
    const serialized = await dehydrateStepReturnValue(
      result,
      mockRunId,
      noEncryptionKey,
      []
    );
    // Step return values are hydrated with workflow revivers
    const hydrated = await hydrateWorkflowArguments(
      serialized,
      mockRunId,
      noEncryptionKey,
      globalThis
    );

    expect(hydrated).toBeInstanceOf(Result);
    expect(hydrated.success).toBe(true);
    expect(hydrated.data).toBe('completed');
  });

  it('should not serialize classes without WORKFLOW_SERIALIZE', async () => {
    class PlainClass {
      constructor(public value: string) {}
    }

    const instance = new PlainClass('test');

    // Should throw because PlainClass is not serializable
    await expect(
      dehydrateWorkflowArguments(instance, mockRunId, noEncryptionKey, [])
    ).rejects.toThrow();
  });

  it('should throw error when classId is missing', async () => {
    // NOTE: Missing `classId` property so serializatoin will fail.
    class NoClassId {
      constructor(public value: string) {}

      static [WORKFLOW_SERIALIZE](instance: NoClassId) {
        return { value: instance.value };
      }

      static [WORKFLOW_DESERIALIZE](data: { value: string }) {
        return new NoClassId(data.value);
      }
    }

    const instance = new NoClassId('test');

    // Should throw with our specific error message about missing classId
    let errorMessage = '';
    try {
      await dehydrateWorkflowArguments(
        instance,
        mockRunId,
        noEncryptionKey,
        []
      );
    } catch (e: any) {
      errorMessage = e.cause?.message || e.message;
    }
    expect(errorMessage).toMatch(/must have a static "classId" property/);
  });

  it('should serialize class with complex data types in payload', async () => {
    class ComplexData {
      constructor(
        public items: Map<string, number>,
        public created: Date
      ) {}

      static [WORKFLOW_SERIALIZE](instance: ComplexData) {
        return { items: instance.items, created: instance.created };
      }

      static [WORKFLOW_DESERIALIZE](data: {
        items: Map<string, number>;
        created: Date;
      }) {
        return new ComplexData(data.items, data.created);
      }
    }

    // The classId is normally generated by the SWC compiler
    (ComplexData as any).classId = 'test/ComplexData';

    // Register the class for deserialization
    registerSerializationClass('test/ComplexData', ComplexData);

    const map = new Map([
      ['a', 1],
      ['b', 2],
    ]);
    const date = new Date('2025-01-01T00:00:00.000Z');
    const complex = new ComplexData(map, date);

    const serialized = await dehydrateWorkflowArguments(
      complex,
      mockRunId,
      noEncryptionKey,
      []
    );
    const hydrated = await hydrateWorkflowArguments(
      serialized,
      mockRunId,
      noEncryptionKey,
      globalThis
    );

    expect(hydrated).toBeInstanceOf(ComplexData);
    expect(hydrated.items).toBeInstanceOf(Map);
    expect(hydrated.items.get('a')).toBe(1);
    expect(hydrated.items.get('b')).toBe(2);
    expect(hydrated.created).toBeInstanceOf(Date);
    expect(hydrated.created.toISOString()).toBe('2025-01-01T00:00:00.000Z');
  });

  it('should pass class as this context to WORKFLOW_SERIALIZE and WORKFLOW_DESERIALIZE', async () => {
    // This test verifies that serialize.call(cls, value) and deserialize.call(cls, data)
    // properly pass the class as `this` context, which is required when the serializer/deserializer
    // needs to access static properties or methods on the class

    class Counter {
      // Static property that the serializer uses via `this`
      static serializedCount = 0;
      static deserializedCount = 0;

      constructor(public value: number) {}

      static [WORKFLOW_SERIALIZE](this: typeof Counter, instance: Counter) {
        // biome-ignore lint/complexity/noThisInStatic: intentionally testing `this` context binding
        this.serializedCount++;
        // biome-ignore lint/complexity/noThisInStatic: intentionally testing `this` context binding
        return { value: instance.value, serializedAt: this.serializedCount };
      }

      static [WORKFLOW_DESERIALIZE](
        this: typeof Counter,
        data: { value: number; serializedAt: number }
      ) {
        // biome-ignore lint/complexity/noThisInStatic: intentionally testing `this` context binding
        this.deserializedCount++;
        return new Counter(data.value);
      }
    }

    // The classId is normally generated by the SWC compiler
    (Counter as any).classId = 'test/Counter';

    // Register the class for serialization/deserialization
    registerSerializationClass('test/Counter', Counter);

    // Reset counters
    Counter.serializedCount = 0;
    Counter.deserializedCount = 0;

    // Serialize an instance - this should increment serializedCount via `this`
    const counter = new Counter(42);
    const serialized = await dehydrateWorkflowArguments(
      counter,
      mockRunId,
      noEncryptionKey,
      []
    );

    // Verify serialization used `this` correctly
    expect(Counter.serializedCount).toBe(1);

    // Deserialize - this should increment deserializedCount via `this`
    const hydrated = await hydrateWorkflowArguments(
      serialized,
      mockRunId,
      noEncryptionKey,
      globalThis
    );

    // Verify deserialization used `this` correctly
    expect(Counter.deserializedCount).toBe(1);
    expect(hydrated).toBeInstanceOf(Counter);
    expect(hydrated.value).toBe(42);

    // Serialize another instance to verify counter increments
    const counter2 = new Counter(100);
    await dehydrateWorkflowArguments(counter2, mockRunId, noEncryptionKey, []);
    expect(Counter.serializedCount).toBe(2);
  });
});

describe('custom Error subclass serialization', () => {
  const { context, globalThis: vmGlobalThis } = createContext({
    seed: 'test-error-serde',
    fixedTimestamp: 1714857600000,
  });

  // Make the serialization symbols available inside the VM
  (vmGlobalThis as any).WORKFLOW_SERIALIZE = WORKFLOW_SERIALIZE;
  (vmGlobalThis as any).WORKFLOW_DESERIALIZE = WORKFLOW_DESERIALIZE;

  // Define registerSerializationClass inside the VM so that it uses the VM's globalThis.
  runInContext(
    `
    const WORKFLOW_CLASS_REGISTRY = Symbol.for('workflow-class-registry');
    function registerSerializationClass(classId, cls) {
      let registry = globalThis[WORKFLOW_CLASS_REGISTRY];
      if (!registry) {
        registry = new Map();
        globalThis[WORKFLOW_CLASS_REGISTRY] = registry;
      }
      registry.set(classId, cls);
      Object.defineProperty(cls, 'classId', {
        value: classId,
        writable: false,
        enumerable: false,
        configurable: false,
      });
    }
    globalThis.registerSerializationClass = registerSerializationClass;
    `,
    context
  );

  it('should use custom serialization for Error subclass with WORKFLOW_SERIALIZE instead of generic Error serialization', async () => {
    // Define an Error subclass with custom serialization that preserves extra fields
    class AppError extends Error {
      constructor(
        message: string,
        public code: number,
        public details: string
      ) {
        super(message);
        this.name = 'AppError';
      }

      static [WORKFLOW_SERIALIZE](instance: AppError) {
        return {
          message: instance.message,
          code: instance.code,
          details: instance.details,
        };
      }

      static [WORKFLOW_DESERIALIZE](data: {
        message: string;
        code: number;
        details: string;
      }) {
        return new AppError(data.message, data.code, data.details);
      }
    }

    // The classId is normally generated by the SWC compiler
    (AppError as any).classId = 'test/AppError';

    // Register the class on the host for serialization
    registerSerializationClass('test/AppError', AppError);

    // Define and register the class inside the VM
    runInContext(
      `
      class AppError extends Error {
        constructor(message, code, details) {
          super(message);
          this.name = 'AppError';
          this.code = code;
          this.details = details;
        }
        static [WORKFLOW_SERIALIZE](instance) {
          return { message: instance.message, code: instance.code, details: instance.details };
        }
        static [WORKFLOW_DESERIALIZE](data) {
          return new AppError(data.message, data.code, data.details);
        }
      }
      AppError.classId = 'test/AppError';
      registerSerializationClass('test/AppError', AppError);
      `,
      context
    );

    const error = new AppError('not found', 404, 'Resource does not exist');

    // Serialize using workflow arguments (which uses getCommonReducers)
    const serialized = await dehydrateWorkflowArguments(
      error,
      mockRunId,
      noEncryptionKey,
      []
    );

    // Verify the serialized data uses Instance (custom class), NOT Error
    const serializedStr = new TextDecoder().decode(serialized);
    expect(serializedStr).toContain('test/AppError');
    expect(serializedStr).toContain('Instance');
    expect(serializedStr).not.toMatch(/"Error"/);

    // Hydrate it back
    const hydrated = await hydrateWorkflowArguments(
      serialized,
      mockRunId,
      noEncryptionKey,
      vmGlobalThis
    );

    // The hydrated object should be an AppError with custom fields preserved
    expect(hydrated.constructor.name).toBe('AppError');
    expect(hydrated.message).toBe('not found');
    expect(hydrated.code).toBe(404);
    expect(hydrated.details).toBe('Resource does not exist');
  });

  it('should still serialize plain Error instances using the generic Error reducer', async () => {
    const error = new Error('plain error');

    const serialized = await dehydrateWorkflowArguments(
      error,
      mockRunId,
      noEncryptionKey,
      []
    );

    // Verify it uses the Error reducer, not Instance
    const serializedStr = new TextDecoder().decode(serialized);
    expect(serializedStr).toContain('Error');
    expect(serializedStr).not.toContain('Instance');

    // Hydrate it back
    const hydrated = await hydrateWorkflowArguments(
      serialized,
      mockRunId,
      noEncryptionKey,
      globalThis
    );

    expect(hydrated).toBeInstanceOf(Error);
    expect(hydrated.message).toBe('plain error');
  });

  it('should serialize Error subclass WITHOUT WORKFLOW_SERIALIZE using generic Error reducer', async () => {
    // An Error subclass that does NOT implement custom serialization
    class SimpleError extends Error {
      constructor(message: string) {
        super(message);
        this.name = 'SimpleError';
      }
    }

    const error = new SimpleError('simple error');

    const serialized = await dehydrateWorkflowArguments(
      error,
      mockRunId,
      noEncryptionKey,
      []
    );

    // Should use generic Error serialization since no WORKFLOW_SERIALIZE
    const serializedStr = new TextDecoder().decode(serialized);
    expect(serializedStr).toContain('Error');
    expect(serializedStr).not.toContain('Instance');

    const hydrated = await hydrateWorkflowArguments(
      serialized,
      mockRunId,
      noEncryptionKey,
      globalThis
    );

    expect(hydrated).toBeInstanceOf(Error);
    expect(hydrated.name).toBe('SimpleError');
    expect(hydrated.message).toBe('simple error');
  });

  it('should use custom serialization for Error subclass in step arguments', async () => {
    class StepError extends Error {
      constructor(
        message: string,
        public statusCode: number
      ) {
        super(message);
        this.name = 'StepError';
      }

      static [WORKFLOW_SERIALIZE](instance: StepError) {
        return { message: instance.message, statusCode: instance.statusCode };
      }

      static [WORKFLOW_DESERIALIZE](data: {
        message: string;
        statusCode: number;
      }) {
        return new StepError(data.message, data.statusCode);
      }
    }

    (StepError as any).classId = 'test/StepError';
    registerSerializationClass('test/StepError', StepError);

    const error = new StepError('bad request', 400);

    const serialized = await dehydrateStepArguments(
      [error],
      mockRunId,
      noEncryptionKey,
      globalThis
    );

    const ops: Promise<void>[] = [];
    const hydrated = await hydrateStepArguments(
      serialized,
      mockRunId,
      noEncryptionKey,
      ops,
      globalThis
    );

    expect(Array.isArray(hydrated)).toBe(true);
    expect(hydrated[0]).toBeInstanceOf(StepError);
    expect(hydrated[0].message).toBe('bad request');
    expect((hydrated[0] as StepError).statusCode).toBe(400);
  });

  it('should use custom serialization for Error subclass in step return values', async () => {
    class ReturnError extends Error {
      constructor(
        message: string,
        public errorCode: string
      ) {
        super(message);
        this.name = 'ReturnError';
      }

      static [WORKFLOW_SERIALIZE](instance: ReturnError) {
        return { message: instance.message, errorCode: instance.errorCode };
      }

      static [WORKFLOW_DESERIALIZE](data: {
        message: string;
        errorCode: string;
      }) {
        return new ReturnError(data.message, data.errorCode);
      }
    }

    (ReturnError as any).classId = 'test/ReturnError';
    registerSerializationClass('test/ReturnError', ReturnError);

    const error = new ReturnError('timeout', 'ERR_TIMEOUT');

    const serialized = await dehydrateStepReturnValue(
      error,
      mockRunId,
      noEncryptionKey,
      []
    );

    // Step return values are hydrated with workflow revivers
    const hydrated = await hydrateWorkflowArguments(
      serialized,
      mockRunId,
      noEncryptionKey,
      globalThis
    );

    expect(hydrated).toBeInstanceOf(ReturnError);
    expect(hydrated.message).toBe('timeout');
    expect(hydrated.errorCode).toBe('ERR_TIMEOUT');
  });
});

describe('DOMException serialization', () => {
  const { context, globalThis: vmGlobalThis } = createContext({
    seed: 'test-domexception',
    fixedTimestamp: 1714857600000,
  });
  vmGlobalThis.Request = globalThis.Request;
  vmGlobalThis.Response = globalThis.Response;
  vmGlobalThis.ReadableStream = globalThis.ReadableStream;
  vmGlobalThis.WritableStream = globalThis.WritableStream;

  async function roundTrip(value: unknown) {
    const serialized = await dehydrateStepReturnValue(
      value,
      mockRunId,
      noEncryptionKey
    );
    return hydrateStepReturnValue(
      serialized,
      mockRunId,
      noEncryptionKey,
      globalThis
    );
  }

  it('should round-trip DOMException with AbortError name', async () => {
    const error = new DOMException('operation aborted', 'AbortError');
    const hydrated = (await roundTrip(error)) as DOMException;
    expect(hydrated).toBeInstanceOf(DOMException);
    expect(hydrated.message).toBe('operation aborted');
    expect(hydrated.name).toBe('AbortError');
    // code is derived from name automatically
    expect(hydrated.code).toBe(20);
  });

  it('should round-trip DOMException with NotFoundError name', async () => {
    const error = new DOMException('resource not found', 'NotFoundError');
    const hydrated = (await roundTrip(error)) as DOMException;
    expect(hydrated).toBeInstanceOf(DOMException);
    expect(hydrated.message).toBe('resource not found');
    expect(hydrated.name).toBe('NotFoundError');
    expect(hydrated.code).toBe(8);
  });

  it('should round-trip DOMException with default name', async () => {
    // When no name is provided, DOMException defaults to "Error"
    const error = new DOMException('something failed');
    const hydrated = (await roundTrip(error)) as DOMException;
    expect(hydrated).toBeInstanceOf(DOMException);
    expect(hydrated.message).toBe('something failed');
    expect(hydrated.name).toBe('Error');
    expect(hydrated.code).toBe(0);
  });

  it('should preserve cause on DOMException when manually set', async () => {
    const error = new DOMException('aborted', 'AbortError');
    (error as any).cause = new TypeError('underlying cause');
    const hydrated = (await roundTrip(error)) as DOMException;
    expect(hydrated).toBeInstanceOf(DOMException);
    expect(hydrated.message).toBe('aborted');
    expect(hydrated.name).toBe('AbortError');
    expect((hydrated.cause as Error).message).toBe('underlying cause');
  });

  it('should not set cause on DOMException when original had none', async () => {
    const error = new DOMException('no cause', 'AbortError');
    expect('cause' in error).toBe(false);
    const hydrated = (await roundTrip(error)) as DOMException;
    expect(hydrated.message).toBe('no cause');
    expect('cause' in hydrated).toBe(false);
  });

  it('should use DOMException serialization key (not generic Error)', async () => {
    const error = new DOMException('test', 'AbortError');
    const serialized = await dehydrateStepReturnValue(
      error,
      mockRunId,
      noEncryptionKey
    );
    const str = new TextDecoder().decode(
      (serialized as Uint8Array).subarray(4)
    );
    expect(str).toContain('DOMException');
    expect(str).not.toMatch(/"Error"/);
  });

  it('should round-trip DOMException across VM boundaries', async () => {
    const hostError = new DOMException('host abort', 'AbortError');
    const serialized = await dehydrateStepReturnValue(
      hostError,
      mockRunId,
      noEncryptionKey
    );
    const hydrated = await hydrateStepReturnValue(
      serialized,
      mockRunId,
      noEncryptionKey,
      vmGlobalThis
    );
    runInContext('var __testVal = null', context);
    (vmGlobalThis as any).__testVal = hydrated;
    expect(runInContext('__testVal instanceof DOMException', context)).toBe(
      true
    );
    expect(runInContext('__testVal.message', context)).toBe('host abort');
    expect(runInContext('__testVal.name', context)).toBe('AbortError');
  });

  it('should have DOMException available in VM context by default', () => {
    // DOMException is a standard Web API that is passed through to the VM
    // context by createContext(), so it should always be available.
    const { context: freshContext } = createContext({
      seed: 'test-dom-available',
      fixedTimestamp: 1714857600000,
    });
    expect(runInContext('typeof DOMException', freshContext)).toBe('function');
    const result = runInContext(
      'new DOMException("test", "AbortError")',
      freshContext
    );
    expect(result).toBeInstanceOf(DOMException);
    expect(result.name).toBe('AbortError');
    expect(result.message).toBe('test');
  });
});

describe('format prefix system', () => {
  const { globalThis: vmGlobalThis } = createContext({
    seed: 'test',
    fixedTimestamp: 1714857600000,
  });

  it('should encode data with format prefix', async () => {
    const data = { message: 'hello' };
    const serialized = await dehydrateWorkflowArguments(
      data,
      mockRunId,
      noEncryptionKey,
      []
    );

    // Check that the first 4 bytes are the format prefix "devl"
    const prefix = new TextDecoder().decode(serialized.subarray(0, 4));
    expect(prefix).toBe('devl');
  });

  it('should decode prefixed data correctly', async () => {
    const data = { message: 'hello', count: 42 };
    const serialized = await dehydrateWorkflowArguments(
      data,
      mockRunId,
      noEncryptionKey,
      []
    );
    const hydrated = await hydrateWorkflowArguments(
      serialized,
      mockRunId,
      noEncryptionKey,
      vmGlobalThis
    );

    expect(hydrated).toEqual({ message: 'hello', count: 42 });
  });

  it('should handle all dehydrate/hydrate function pairs with format prefix', async () => {
    const testData = { test: 'data', nested: { value: 123 } };

    // Workflow arguments
    const workflowArgs = await dehydrateWorkflowArguments(
      testData,
      mockRunId,
      noEncryptionKey,
      []
    );
    expect(new TextDecoder().decode(workflowArgs.subarray(0, 4))).toBe('devl');
    expect(
      await hydrateWorkflowArguments(
        workflowArgs,
        mockRunId,
        noEncryptionKey,
        vmGlobalThis
      )
    ).toEqual(testData);

    // Workflow return value
    const workflowReturn = await dehydrateWorkflowReturnValue(
      testData,
      mockRunId,
      noEncryptionKey,
      globalThis
    );
    expect(new TextDecoder().decode(workflowReturn.subarray(0, 4))).toBe(
      'devl'
    );
    expect(
      await hydrateWorkflowReturnValue(
        workflowReturn,
        mockRunId,
        noEncryptionKey,
        [],
        vmGlobalThis
      )
    ).toEqual(testData);

    // Step arguments
    const stepArgs = await dehydrateStepArguments(
      testData,
      mockRunId,
      noEncryptionKey,
      globalThis
    );
    expect(new TextDecoder().decode(stepArgs.subarray(0, 4))).toBe('devl');
    expect(
      await hydrateStepArguments(
        stepArgs,
        mockRunId,
        noEncryptionKey,
        [],
        vmGlobalThis
      )
    ).toEqual(testData);

    // Step return value
    const stepReturn = await dehydrateStepReturnValue(
      testData,
      mockRunId,
      noEncryptionKey,
      []
    );
    expect(new TextDecoder().decode(stepReturn.subarray(0, 4))).toBe('devl');
    expect(
      await hydrateStepReturnValue(
        stepReturn,
        mockRunId,
        noEncryptionKey,
        vmGlobalThis
      )
    ).toEqual(testData);
  });

  it('should throw error for unknown format prefix', async () => {
    // Create data with an unknown 4-character format prefix
    const unknownFormat = new TextEncoder().encode('unkn{"test":true}');

    await expect(
      hydrateWorkflowArguments(
        unknownFormat,
        mockRunId,
        noEncryptionKey,
        vmGlobalThis
      )
    ).rejects.toThrow(/Unknown serialization format/);
  });

  it('should throw error for data too short to contain format prefix', async () => {
    const tooShort = new TextEncoder().encode('dev');

    await expect(
      hydrateWorkflowArguments(
        tooShort,
        mockRunId,
        noEncryptionKey,
        vmGlobalThis
      )
    ).rejects.toThrow(/Data too short to contain format prefix/);
  });
});

describe('decodeFormatPrefix legacy compatibility', () => {
  it('should handle legacy object data (non-Uint8Array)', () => {
    const legacyData = { message: 'hello', count: 42 };
    const result = decodeFormatPrefix(legacyData);

    expect(result.format).toBe(SerializationFormat.DEVALUE_V1);
    expect(result.payload).toBeInstanceOf(Uint8Array);

    // The payload should be JSON-encoded
    const decoded = new TextDecoder().decode(result.payload);
    expect(JSON.parse(decoded)).toEqual(legacyData);
  });

  it('should handle legacy array data (non-Uint8Array)', () => {
    const legacyData = [1, 2, 'three', { nested: true }];
    const result = decodeFormatPrefix(legacyData);

    expect(result.format).toBe(SerializationFormat.DEVALUE_V1);
    expect(result.payload).toBeInstanceOf(Uint8Array);

    const decoded = new TextDecoder().decode(result.payload);
    expect(JSON.parse(decoded)).toEqual(legacyData);
  });

  it('should handle legacy undefined data (non-Uint8Array)', () => {
    const legacyData = undefined;
    const result = decodeFormatPrefix(legacyData);

    expect(result.format).toBe(SerializationFormat.DEVALUE_V1);
    expect(result.payload).toBeInstanceOf(Uint8Array);

    // JSON.stringify(undefined) returns undefined (not a string),
    // which when encoded produces an empty Uint8Array
    expect(result.payload.length).toBe(0);
  });

  it('should still correctly handle v2 Uint8Array data', () => {
    // Create valid v2 data with 'devl' prefix
    const payload = new TextEncoder().encode('["test"]');
    const v2Data = new Uint8Array(4 + payload.length);
    v2Data.set(new TextEncoder().encode('devl'), 0);
    v2Data.set(payload, 4);

    const result = decodeFormatPrefix(v2Data);

    expect(result.format).toBe(SerializationFormat.DEVALUE_V1);
    expect(result.payload).toBeInstanceOf(Uint8Array);

    const decoded = new TextDecoder().decode(result.payload);
    expect(decoded).toBe('["test"]');
  });
});

// ---------------------------------------------------------------------------
// getSerializeStream / getDeserializeStream
// ---------------------------------------------------------------------------

describe('getSerializeStream', () => {
  // Empty reducers work for plain JSON-compatible values
  const reducers = {} as any;

  /** Write values and collect output concurrently (avoids backpressure deadlock) */
  async function serializeValues(values: unknown[]): Promise<Uint8Array[]> {
    const serialize = getSerializeStream(reducers, undefined);
    const results: Uint8Array[] = [];

    // Start reading before writing to avoid backpressure deadlock
    const readPromise = (async () => {
      const reader = serialize.readable.getReader();
      for (;;) {
        const { value, done } = await reader.read();
        if (done) break;
        results.push(value);
      }
    })();

    const writer = serialize.writable.getWriter();
    for (const value of values) {
      await writer.write(value);
    }
    await writer.close();
    await readPromise;
    return results;
  }

  /** Feed Uint8Array chunks into a deserialize stream and collect results */
  async function deserializeChunks(
    chunks: Uint8Array[],
    revivers: any
  ): Promise<unknown[]> {
    const deserialize = getDeserializeStream(revivers, undefined);
    const results: unknown[] = [];

    const readPromise = (async () => {
      const reader = deserialize.readable.getReader();
      for (;;) {
        const { value, done } = await reader.read();
        if (done) break;
        results.push(value);
      }
    })();

    const writer = deserialize.writable.getWriter();
    for (const chunk of chunks) {
      await writer.write(chunk);
    }
    await writer.close();
    await readPromise;
    return results;
  }

  it('should serialize each chunk with format prefix and length framing', async () => {
    const chunks = await serializeValues([{ hello: 'world' }, 42]);
    expect(chunks).toHaveLength(2);

    for (const chunk of chunks) {
      expect(chunk).toBeInstanceOf(Uint8Array);
      // Each chunk should be: [4-byte length][devl...payload...]
      expect(chunk.length).toBeGreaterThan(8); // 4 header + 4 prefix + payload

      // Read the length header
      const view = new DataView(
        chunk.buffer,
        chunk.byteOffset,
        chunk.byteLength
      );
      const frameLength = view.getUint32(0, false);
      expect(frameLength).toBe(chunk.length - 4);

      // Read the format prefix
      const prefix = new TextDecoder().decode(chunk.subarray(4, 8));
      expect(prefix).toBe('devl');
    }
  });

  it('should produce chunks that getDeserializeStream can parse', async () => {
    const revivers = getCommonRevivers(globalThis) as any;
    const original = [
      { message: 'hello', count: 42 },
      [1, 2, 3],
      'plain string',
      null,
    ];

    const serialized = await serializeValues(original);
    const results = await deserializeChunks(serialized, revivers);

    expect(results).toHaveLength(4);
    expect(results[0]).toEqual({ message: 'hello', count: 42 });
    expect(results[1]).toEqual([1, 2, 3]);
    expect(results[2]).toBe('plain string');
    expect(results[3]).toBe(null);
  });

  it('should handle deserializing when chunks are concatenated', async () => {
    const revivers = getCommonRevivers(globalThis) as any;
    const serialized = await serializeValues([{ a: 1 }, { b: 2 }, { c: 3 }]);

    // Concatenate all chunks into a single Uint8Array (simulates
    // transport coalescing multiple chunks into one read)
    const totalLength = serialized.reduce((sum, c) => sum + c.length, 0);
    const concatenated = new Uint8Array(totalLength);
    let offset = 0;
    for (const chunk of serialized) {
      concatenated.set(chunk, offset);
      offset += chunk.length;
    }

    const results = await deserializeChunks([concatenated], revivers);
    expect(results).toHaveLength(3);
    expect(results[0]).toEqual({ a: 1 });
    expect(results[1]).toEqual({ b: 2 });
    expect(results[2]).toEqual({ c: 3 });
  });

  it('should handle deserializing when chunks are split arbitrarily', async () => {
    const revivers = getCommonRevivers(globalThis) as any;
    const serialized = await serializeValues([{ key: 'value' }]);
    const fullData = serialized[0];

    // Split the chunk at an arbitrary point (in the middle of the frame)
    const splitPoint = Math.floor(fullData.length / 2);
    const part1 = fullData.slice(0, splitPoint);
    const part2 = fullData.slice(splitPoint);

    const results = await deserializeChunks([part1, part2], revivers);
    expect(results).toHaveLength(1);
    expect(results[0]).toEqual({ key: 'value' });
  });
});

describe('getDeserializeStream legacy fallback', () => {
  const revivers = getCommonRevivers(globalThis) as any;

  /** Feed Uint8Array chunks into a deserialize stream and collect results */
  async function deserializeChunks(chunks: Uint8Array[]): Promise<unknown[]> {
    const deserialize = getDeserializeStream(revivers, undefined);
    const results: unknown[] = [];

    const readPromise = (async () => {
      const reader = deserialize.readable.getReader();
      for (;;) {
        const { value, done } = await reader.read();
        if (done) break;
        results.push(value);
      }
    })();

    const writer = deserialize.writable.getWriter();
    for (const chunk of chunks) {
      await writer.write(chunk);
    }
    await writer.close();
    await readPromise;
    return results;
  }

  it('should parse legacy newline-delimited devalue text', async () => {
    const { stringify } = await import('devalue');
    const encoder = new TextEncoder();

    const line1 = stringify({ hello: 'world' }) + '\n';
    const line2 = stringify(42) + '\n';
    const legacyData = encoder.encode(line1 + line2);

    const results = await deserializeChunks([legacyData]);
    expect(results).toHaveLength(2);
    expect(results[0]).toEqual({ hello: 'world' });
    expect(results[1]).toBe(42);
  });

  it('should parse legacy single-line chunks', async () => {
    const { stringify } = await import('devalue');
    const encoder = new TextEncoder();

    const chunk1 = encoder.encode(stringify('hello') + '\n');
    const chunk2 = encoder.encode(stringify('world') + '\n');

    const results = await deserializeChunks([chunk1, chunk2]);
    expect(results).toHaveLength(2);
    expect(results[0]).toBe('hello');
    expect(results[1]).toBe('world');
  });
});

describe('stream encryption round-trip', () => {
  // Real 32-byte AES-256 test key
  const testKeyRaw = new Uint8Array([
    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
    0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
    0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
  ]);
  let cryptoKey: CryptoKey;
  beforeAll(async () => {
    cryptoKey = await importKey(testKeyRaw);
  });

  const reducers = {} as any;
  const revivers = getCommonRevivers(globalThis) as any;

  /** Serialize values through an encrypted stream */
  async function encryptedSerialize(values: unknown[]): Promise<Uint8Array[]> {
    const serialize = getSerializeStream(reducers, cryptoKey);
    const results: Uint8Array[] = [];
    const readPromise = (async () => {
      const reader = serialize.readable.getReader();
      for (;;) {
        const { value, done } = await reader.read();
        if (done) break;
        results.push(value);
      }
    })();
    const writer = serialize.writable.getWriter();
    for (const value of values) {
      await writer.write(value);
    }
    await writer.close();
    await readPromise;
    return results;
  }

  /** Deserialize chunks through a decrypting stream */
  async function encryptedDeserialize(
    chunks: Uint8Array[],
    key: CryptoKey | undefined
  ): Promise<unknown[]> {
    const deserialize = getDeserializeStream(revivers, key);
    const results: unknown[] = [];
    const readPromise = (async () => {
      const reader = deserialize.readable.getReader();
      for (;;) {
        const { value, done } = await reader.read();
        if (done) break;
        results.push(value);
      }
    })();
    const writer = deserialize.writable.getWriter();
    for (const chunk of chunks) {
      await writer.write(chunk);
    }
    await writer.close();
    await readPromise;
    return results;
  }

  it('should produce encrypted frames with encr prefix inside length header', async () => {
    const chunks = await encryptedSerialize([{ hello: 'world' }]);
    expect(chunks).toHaveLength(1);

    const chunk = chunks[0];
    // Frame structure: [4-byte length][encr...encrypted payload...]
    expect(chunk.length).toBeGreaterThan(8);

    // Length header should be valid
    const view = new DataView(chunk.buffer, chunk.byteOffset, chunk.byteLength);
    const frameLength = view.getUint32(0, false);
    expect(frameLength).toBe(chunk.length - 4);

    // Format prefix should be 'encr' (not 'devl')
    const prefix = new TextDecoder().decode(chunk.subarray(4, 8));
    expect(prefix).toBe('encr');
  });

  it('should round-trip encrypted serialize -> deserialize with correct key', async () => {
    const original = [
      { message: 'secret', count: 42 },
      [1, 2, 3],
      'plain string',
      null,
      true,
    ];

    const encrypted = await encryptedSerialize(original);
    const results = await encryptedDeserialize(encrypted, cryptoKey);

    expect(results).toHaveLength(5);
    expect(results[0]).toEqual({ message: 'secret', count: 42 });
    expect(results[1]).toEqual([1, 2, 3]);
    expect(results[2]).toBe('plain string');
    expect(results[3]).toBe(null);
    expect(results[4]).toBe(true);
  });

  it('should handle multiple encrypted frames concatenated into a single chunk', async () => {
    const encrypted = await encryptedSerialize([{ a: 1 }, { b: 2 }, { c: 3 }]);

    // Concatenate all frames into one big chunk (simulating transport coalescing)
    const totalLength = encrypted.reduce((sum, c) => sum + c.length, 0);
    const concatenated = new Uint8Array(totalLength);
    let offset = 0;
    for (const chunk of encrypted) {
      concatenated.set(chunk, offset);
      offset += chunk.length;
    }

    const results = await encryptedDeserialize([concatenated], cryptoKey);
    expect(results).toHaveLength(3);
    expect(results[0]).toEqual({ a: 1 });
    expect(results[1]).toEqual({ b: 2 });
    expect(results[2]).toEqual({ c: 3 });
  });

  it('should handle encrypted frames split across multiple transport chunks', async () => {
    const encrypted = await encryptedSerialize([{ data: 'split me' }]);
    const frame = encrypted[0];

    // Split the single frame into two chunks at an arbitrary point
    const splitPoint = Math.floor(frame.length / 2);
    const chunk1 = frame.slice(0, splitPoint);
    const chunk2 = frame.slice(splitPoint);

    const results = await encryptedDeserialize([chunk1, chunk2], cryptoKey);
    expect(results).toHaveLength(1);
    expect(results[0]).toEqual({ data: 'split me' });
  });

  it('should error when encrypted data is encountered without a key', async () => {
    const encrypted = await encryptedSerialize([{ secret: true }]);

    // Try to deserialize without a key — should error
    const deserialize = getDeserializeStream(revivers, undefined);

    const readPromise = (async () => {
      const reader = deserialize.readable.getReader();
      const results: unknown[] = [];
      for (;;) {
        const { value, done } = await reader.read();
        if (done) break;
        results.push(value);
      }
      return results;
    })();

    const writer = deserialize.writable.getWriter();
    for (const chunk of encrypted) {
      // The write or close may throw because controller.error() aborts the stream
      await writer.write(chunk).catch(() => {});
    }
    await writer.close().catch(() => {});

    await expect(readPromise).rejects.toThrow(
      'Encrypted stream data encountered but no encryption key is available'
    );
  });

  it('should not encrypt when cryptoKey is undefined', async () => {
    // Serialize without encryption
    const serialize = getSerializeStream(reducers, undefined);
    const results: Uint8Array[] = [];
    const readPromise = (async () => {
      const reader = serialize.readable.getReader();
      for (;;) {
        const { value, done } = await reader.read();
        if (done) break;
        results.push(value);
      }
    })();
    const writer = serialize.writable.getWriter();
    await writer.write({ hello: 'world' });
    await writer.close();
    await readPromise;

    // Should have 'devl' prefix (not 'encr')
    const prefix = new TextDecoder().decode(results[0].subarray(4, 8));
    expect(prefix).toBe('devl');

    // Should be deserializable without a key
    const deserialized = await encryptedDeserialize(results, undefined);
    expect(deserialized[0]).toEqual({ hello: 'world' });
  });

  it('should handle large payloads with encryption', async () => {
    // Create a large object that produces a significant serialized payload
    const largeArray = Array.from({ length: 1000 }, (_, i) => ({
      index: i,
      value: `item-${i}`,
      nested: { a: i * 2, b: i * 3 },
    }));

    const encrypted = await encryptedSerialize([largeArray]);
    const results = await encryptedDeserialize(encrypted, cryptoKey);

    expect(results).toHaveLength(1);
    expect(results[0]).toEqual(largeArray);
  });
});

describe('encryption integration', () => {
  // Real 32-byte AES-256 test key (raw bytes for importKey)
  const testKeyRaw = new Uint8Array([
    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
    0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
    0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
  ]);
  // A different key for wrong-key tests
  const wrongKeyRaw = new Uint8Array(32);
  wrongKeyRaw.fill(0xff);

  let testKey: CryptoKey;
  let wrongKey: CryptoKey;
  beforeAll(async () => {
    testKey = await importKey(testKeyRaw);
    wrongKey = await importKey(wrongKeyRaw);
  });

  it('should encrypt workflow arguments when key is provided', async () => {
    const testRunId = 'wrun_test123';
    const testValue = { message: 'secret data', count: 42 };

    const encrypted = await dehydrateWorkflowArguments(
      testValue,
      testRunId,
      testKey,
      [],
      globalThis,
      false
    );

    // Should be a Uint8Array with 'encr' prefix
    expect(encrypted).toBeInstanceOf(Uint8Array);
    const prefix = new TextDecoder().decode(
      (encrypted as Uint8Array).subarray(0, 4)
    );
    expect(prefix).toBe('encr');
  });

  it('should decrypt workflow arguments with correct key', async () => {
    const testRunId = 'wrun_test123';
    const testValue = { message: 'secret data', count: 42 };

    const encrypted = await dehydrateWorkflowArguments(
      testValue,
      testRunId,
      testKey,
      [],
      globalThis,
      false
    );

    const decrypted = await hydrateWorkflowArguments(
      encrypted,
      testRunId,
      testKey,
      globalThis,
      {}
    );

    expect(decrypted).toEqual(testValue);
  });

  it('should fail to decrypt with wrong key', async () => {
    const testRunId = 'wrun_test123';
    const testValue = { message: 'secret data' };

    const encrypted = await dehydrateWorkflowArguments(
      testValue,
      testRunId,
      testKey,
      [],
      globalThis,
      false
    );

    // AES-GCM auth tag check should fail with wrong key
    await expect(
      hydrateWorkflowArguments(encrypted, testRunId, wrongKey, globalThis, {})
    ).rejects.toThrow();
  });

  it('should not encrypt when no key is provided', async () => {
    const testRunId = 'wrun_test123';
    const testValue = { message: 'plain data' };

    const serialized = await dehydrateWorkflowArguments(
      testValue,
      testRunId,
      undefined,
      [],
      globalThis,
      false
    );

    // Should be a Uint8Array with 'devl' prefix (not encrypted)
    expect(serialized).toBeInstanceOf(Uint8Array);
    const prefix = new TextDecoder().decode(
      (serialized as Uint8Array).subarray(0, 4)
    );
    expect(prefix).toBe('devl');
  });

  it('should handle unencrypted data when key is provided', async () => {
    const testRunId = 'wrun_test123';
    const testValue = { message: 'plain data' };

    // Serialize without encryption
    const serialized = await dehydrateWorkflowArguments(
      testValue,
      testRunId,
      undefined,
      [],
      globalThis,
      false
    );

    // Hydrate with key — should still work because data isn't encrypted
    const hydrated = await hydrateWorkflowArguments(
      serialized,
      testRunId,
      testKey,
      globalThis,
      {}
    );

    expect(hydrated).toEqual(testValue);
  });

  it('should encrypt step arguments', async () => {
    const testRunId = 'wrun_test123';
    const testValue = ['arg1', { nested: 'value' }, 123];

    const encrypted = await dehydrateStepArguments(
      testValue,
      testRunId,
      testKey,
      globalThis,
      false
    );

    // Should have 'encr' prefix
    expect(encrypted).toBeInstanceOf(Uint8Array);
    const prefix = new TextDecoder().decode(
      (encrypted as Uint8Array).subarray(0, 4)
    );
    expect(prefix).toBe('encr');

    // Should round-trip correctly
    const decrypted = await hydrateStepArguments(
      encrypted,
      testRunId,
      testKey,
      [],
      globalThis
    );

    expect(decrypted).toEqual(testValue);
  });

  it('should encrypt step return values', async () => {
    const testRunId = 'wrun_test123';
    const testValue = { result: 'success', data: [1, 2, 3] };

    const encrypted = await dehydrateStepReturnValue(
      testValue,
      testRunId,
      testKey,
      [],
      globalThis
    );

    // Should have 'encr' prefix
    expect(encrypted).toBeInstanceOf(Uint8Array);
    const prefix = new TextDecoder().decode(
      (encrypted as Uint8Array).subarray(0, 4)
    );
    expect(prefix).toBe('encr');

    // Should round-trip correctly
    const decrypted = await hydrateStepReturnValue(
      encrypted,
      testRunId,
      testKey,
      globalThis
    );

    expect(decrypted).toEqual(testValue);
  });

  it('should encrypt workflow return values', async () => {
    const testRunId = 'wrun_test123';
    const testValue = { final: 'result', timestamp: Date.now() };

    const encrypted = await dehydrateWorkflowReturnValue(
      testValue,
      testRunId,
      testKey,
      globalThis
    );

    // Should have 'encr' prefix
    expect(encrypted).toBeInstanceOf(Uint8Array);
    const prefix = new TextDecoder().decode(
      (encrypted as Uint8Array).subarray(0, 4)
    );
    expect(prefix).toBe('encr');

    // Should round-trip correctly
    const decrypted = await hydrateWorkflowReturnValue(
      encrypted,
      testRunId,
      testKey,
      [],
      globalThis,
      {}
    );

    expect(decrypted).toEqual(testValue);
  });

  it('should produce different ciphertext for same plaintext (nonce randomness)', async () => {
    const testRunId = 'wrun_test123';
    const testValue = { message: 'same data' };

    const encrypted1 = await dehydrateWorkflowArguments(
      testValue,
      testRunId,
      testKey,
      [],
      globalThis,
      false
    );

    const encrypted2 = await dehydrateWorkflowArguments(
      testValue,
      testRunId,
      testKey,
      [],
      globalThis,
      false
    );

    // Both should decrypt to the same value
    const decrypted1 = await hydrateWorkflowArguments(
      encrypted1,
      testRunId,
      testKey,
      globalThis
    );
    const decrypted2 = await hydrateWorkflowArguments(
      encrypted2,
      testRunId,
      testKey,
      globalThis
    );
    expect(decrypted1).toEqual(testValue);
    expect(decrypted2).toEqual(testValue);

    // But the ciphertext should differ due to random nonce
    expect(encrypted1).not.toEqual(encrypted2);
  });

  it('should throw when decrypting encrypted data without a key', async () => {
    const testRunId = 'wrun_test123';
    const testValue = { message: 'secret' };

    const encrypted = await dehydrateWorkflowArguments(
      testValue,
      testRunId,
      testKey,
      [],
      globalThis,
      false
    );

    await expect(
      hydrateWorkflowArguments(encrypted, testRunId, undefined, globalThis)
    ).rejects.toThrow('Encrypted data encountered but no encryption key');
  });

  it('should round-trip Date through encryption', async () => {
    const testRunId = 'wrun_test123';
    const testValue = new Date('2025-07-17T04:30:34.824Z');

    const encrypted = await dehydrateWorkflowArguments(
      testValue,
      testRunId,
      testKey,
      []
    );
    const decrypted = await hydrateWorkflowArguments(
      encrypted,
      testRunId,
      testKey
    );

    expect(decrypted).toBeInstanceOf(Date);
    expect((decrypted as Date).toISOString()).toBe('2025-07-17T04:30:34.824Z');
  });

  it('should round-trip Map through encryption', async () => {
    const testRunId = 'wrun_test123';
    const testValue = new Map([
      ['key1', 'value1'],
      ['key2', 42],
    ]);

    const encrypted = await dehydrateWorkflowArguments(
      testValue,
      testRunId,
      testKey,
      []
    );
    const decrypted = (await hydrateWorkflowArguments(
      encrypted,
      testRunId,
      testKey
    )) as Map<string, unknown>;

    expect(decrypted).toBeInstanceOf(Map);
    expect(decrypted.get('key1')).toBe('value1');
    expect(decrypted.get('key2')).toBe(42);
  });

  it('should round-trip Set through encryption', async () => {
    const testRunId = 'wrun_test123';
    const testValue = new Set([1, 'two', true]);

    const encrypted = await dehydrateWorkflowArguments(
      testValue,
      testRunId,
      testKey,
      []
    );
    const decrypted = (await hydrateWorkflowArguments(
      encrypted,
      testRunId,
      testKey
    )) as Set<unknown>;

    expect(decrypted).toBeInstanceOf(Set);
    expect(decrypted.has(1)).toBe(true);
    expect(decrypted.has('two')).toBe(true);
    expect(decrypted.has(true)).toBe(true);
  });

  it('should round-trip BigInt through encryption', async () => {
    const testRunId = 'wrun_test123';
    const testValue = BigInt('9007199254740992');

    const encrypted = await dehydrateWorkflowArguments(
      testValue,
      testRunId,
      testKey,
      []
    );
    const decrypted = await hydrateWorkflowArguments(
      encrypted,
      testRunId,
      testKey
    );

    expect(decrypted).toBe(BigInt('9007199254740992'));
  });
});

describe('encrypt/decrypt primitives', () => {
  const testKeyRaw = new Uint8Array([
    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
    0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
    0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
  ]);
  let testKey: CryptoKey;
  beforeAll(async () => {
    testKey = await importKey(testKeyRaw);
  });

  it('should round-trip arbitrary data', async () => {
    const data = new TextEncoder().encode('hello world');
    const encrypted = await encrypt(testKey, data);
    const decrypted = await decrypt(testKey, encrypted);
    expect(decrypted).toEqual(data);
  });

  it('should round-trip empty data', async () => {
    const data = new Uint8Array(0);
    const encrypted = await encrypt(testKey, data);
    const decrypted = await decrypt(testKey, encrypted);
    expect(decrypted).toEqual(data);
  });

  it('should produce nonce + ciphertext output', async () => {
    const data = new TextEncoder().encode('test');
    const encrypted = await encrypt(testKey, data);
    // Output should be: 12 bytes nonce + ciphertext (at least 16 bytes for GCM auth tag)
    expect(encrypted.byteLength).toBeGreaterThanOrEqual(12 + 16);
  });

  it('should produce different ciphertext each time (random nonce)', async () => {
    const data = new TextEncoder().encode('same input');
    const enc1 = await encrypt(testKey, data);
    const enc2 = await encrypt(testKey, data);
    // Different nonces → different ciphertext
    expect(enc1).not.toEqual(enc2);
    // But both decrypt to the same plaintext
    expect(await decrypt(testKey, enc1)).toEqual(data);
    expect(await decrypt(testKey, enc2)).toEqual(data);
  });

  it('should reject keys that are not 32 bytes via importKey', async () => {
    const shortKey = new Uint8Array(16);
    await expect(importKey(shortKey)).rejects.toThrow(
      'Encryption key must be exactly 32 bytes'
    );
  });

  it('should reject truncated ciphertext', async () => {
    const tooShort = new Uint8Array(10); // Less than nonce (12) + auth tag (16)
    await expect(decrypt(testKey, tooShort)).rejects.toThrow(
      'Encrypted data too short'
    );
  });

  it('should fail with wrong key (auth tag mismatch)', async () => {
    const data = new TextEncoder().encode('secret');
    const encrypted = await encrypt(testKey, data);
    const wrongKey = await importKey(new Uint8Array(32).fill(0xff));
    await expect(decrypt(wrongKey, encrypted)).rejects.toThrow();
  });

  it('should fail with tampered ciphertext', async () => {
    const data = new TextEncoder().encode('integrity check');
    const encrypted = await encrypt(testKey, data);
    // Flip a byte in the ciphertext (past the nonce)
    encrypted[15] ^= 0xff;
    await expect(decrypt(testKey, encrypted)).rejects.toThrow();
  });
});

describe('maybeEncrypt / maybeDecrypt', () => {
  const testKeyRaw = new Uint8Array([
    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
    0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
    0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
  ]);
  let testKey: CryptoKey;
  beforeAll(async () => {
    testKey = await importKey(testKeyRaw);
  });

  it('should pass through data unchanged when key is undefined', async () => {
    const data = new Uint8Array([1, 2, 3, 4]);
    const result = await maybeEncrypt(data, undefined);
    expect(result).toBe(data); // Same reference
  });

  it('should encrypt and add "encr" prefix when key is provided', async () => {
    const data = new Uint8Array([1, 2, 3, 4]);
    const result = await maybeEncrypt(data, testKey);
    expect(result).not.toBe(data);
    expect(isEncrypted(result)).toBe(true);
  });

  it('should round-trip through maybeEncrypt/maybeDecrypt', async () => {
    const data = new Uint8Array([10, 20, 30, 40, 50]);
    const encrypted = await maybeEncrypt(data, testKey);
    const decrypted = await maybeDecrypt(encrypted, testKey);
    expect(decrypted).toEqual(data);
  });

  it('should pass through non-Uint8Array values in maybeDecrypt', async () => {
    const legacyData = [1, 'hello', { key: 'value' }];
    const result = await maybeDecrypt(legacyData, testKey);
    expect(result).toBe(legacyData); // Same reference
  });

  it('should pass through unencrypted Uint8Array in maybeDecrypt', async () => {
    // Data with 'devl' prefix (not encrypted)
    const prefix = new TextEncoder().encode('devl');
    const payload = new TextEncoder().encode('test');
    const data = new Uint8Array(prefix.length + payload.length);
    data.set(prefix, 0);
    data.set(payload, prefix.length);

    const result = await maybeDecrypt(data, testKey);
    expect(result).toBe(data); // Same reference — not encrypted, passed through
  });

  it('should throw when encrypted data has no key', async () => {
    const data = new Uint8Array([1, 2, 3]);
    const encrypted = await maybeEncrypt(data, testKey);
    await expect(maybeDecrypt(encrypted, undefined)).rejects.toThrow(
      'Encrypted data encountered but no encryption key'
    );
  });
});

describe('isEncrypted', () => {
  it('should return true for data with "encr" prefix', () => {
    const prefix = new TextEncoder().encode('encr');
    const data = new Uint8Array(prefix.length + 10);
    data.set(prefix, 0);
    expect(isEncrypted(data)).toBe(true);
  });

  it('should return false for data with "devl" prefix', () => {
    const prefix = new TextEncoder().encode('devl');
    const data = new Uint8Array(prefix.length + 10);
    data.set(prefix, 0);
    expect(isEncrypted(data)).toBe(false);
  });

  it('should return false for non-Uint8Array values', () => {
    expect(isEncrypted('hello')).toBe(false);
    expect(isEncrypted(42)).toBe(false);
    expect(isEncrypted(null)).toBe(false);
    expect(isEncrypted(undefined)).toBe(false);
    expect(isEncrypted([1, 2, 3])).toBe(false);
  });

  it('should return false for data shorter than prefix length', () => {
    expect(isEncrypted(new Uint8Array(2))).toBe(false);
  });
});

// ============================================================================
// AbortController / AbortSignal serialization
// ============================================================================

describe('AbortController serialization', () => {
  const { context, globalThis: vmGlobalThis } = createContext({
    seed: 'test-abort-serde',
    fixedTimestamp: 1714857600000,
  });
  // The workflow VM does NOT use the real AbortController/AbortSignal
  // (their prototypes have getter-only properties like `aborted`).
  // The real workflow VM uses lightweight stubs from workflow/abort-controller.ts.
  // Workflow revivers use Object.create(global.AbortController?.prototype ?? {})
  // which falls back to a plain object when the VM doesn't have them set.

  // Set up common web globals that workflow reducers check via instanceof
  vmGlobalThis.Request = globalThis.Request;
  vmGlobalThis.Response = globalThis.Response;
  vmGlobalThis.Headers = globalThis.Headers;
  vmGlobalThis.ReadableStream = globalThis.ReadableStream;
  vmGlobalThis.WritableStream = globalThis.WritableStream;

  describe('workflow arguments (external → workflow)', () => {
    it('AbortController round-trip preserves type, signal.aborted === false', async () => {
      const originalStableUlid = (globalThis as any)[STABLE_ULID];
      (globalThis as any)[STABLE_ULID] = () => '01ABORT0000000000001';
      try {
        const controller = new AbortController();
        const ops: Promise<void>[] = [];

        const serialized = await dehydrateWorkflowArguments(
          controller,
          mockRunId,
          noEncryptionKey,
          ops
        );

        const hydrated = await hydrateWorkflowArguments(
          serialized,
          mockRunId,
          noEncryptionKey,
          vmGlobalThis
        );

        // Workflow revivers produce stubs with symbols and properties
        expect(hydrated.signal).toBeDefined();
        expect(hydrated.signal.aborted).toBe(false);
        expect((hydrated as any)[ABORT_STREAM_NAME]).toBeDefined();
        expect((hydrated as any)[ABORT_HOOK_TOKEN]).toBeDefined();
        expect((hydrated.signal as any)[ABORT_STREAM_NAME]).toBeDefined();
        expect((hydrated.signal as any)[ABORT_HOOK_TOKEN]).toBeDefined();
      } finally {
        (globalThis as any)[STABLE_ULID] = originalStableUlid;
      }
    });

    it('already-aborted AbortController: signal.aborted === true after hydration', async () => {
      const originalStableUlid = (globalThis as any)[STABLE_ULID];
      (globalThis as any)[STABLE_ULID] = () => '01ABORT0000000000002';
      try {
        const controller = new AbortController();
        controller.abort('test reason');
        const ops: Promise<void>[] = [];

        const serialized = await dehydrateWorkflowArguments(
          controller,
          mockRunId,
          noEncryptionKey,
          ops
        );

        const hydrated = await hydrateWorkflowArguments(
          serialized,
          mockRunId,
          noEncryptionKey,
          vmGlobalThis
        );

        expect(hydrated.signal.aborted).toBe(true);
        expect(hydrated.signal.reason).toBe('test reason');
      } finally {
        (globalThis as any)[STABLE_ULID] = originalStableUlid;
      }
    });

    it('AbortSignal (standalone) round-trip', async () => {
      const originalStableUlid = (globalThis as any)[STABLE_ULID];
      (globalThis as any)[STABLE_ULID] = () => '01ABORT0000000000003';
      try {
        const controller = new AbortController();
        const signal = controller.signal;
        const ops: Promise<void>[] = [];

        const serialized = await dehydrateWorkflowArguments(
          signal,
          mockRunId,
          noEncryptionKey,
          ops
        );

        const hydrated = await hydrateWorkflowArguments(
          serialized,
          mockRunId,
          noEncryptionKey,
          vmGlobalThis
        );

        expect(hydrated.aborted).toBe(false);
        expect((hydrated as any)[ABORT_STREAM_NAME]).toBeDefined();
        expect((hydrated as any)[ABORT_HOOK_TOKEN]).toBeDefined();
      } finally {
        (globalThis as any)[STABLE_ULID] = originalStableUlid;
      }
    });

    it('AbortSignal.abort() static: serialized with aborted=true', async () => {
      const originalStableUlid = (globalThis as any)[STABLE_ULID];
      (globalThis as any)[STABLE_ULID] = () => '01ABORT0000000000004';
      try {
        // Use a string reason because the default DOMException from
        // AbortSignal.abort() is not serializable (isNativeError returns
        // false for DOMException)
        const signal = AbortSignal.abort('aborted');
        const ops: Promise<void>[] = [];

        const serialized = await dehydrateWorkflowArguments(
          signal,
          mockRunId,
          noEncryptionKey,
          ops
        );

        const hydrated = await hydrateWorkflowArguments(
          serialized,
          mockRunId,
          noEncryptionKey,
          vmGlobalThis
        );

        expect(hydrated.aborted).toBe(true);
      } finally {
        (globalThis as any)[STABLE_ULID] = originalStableUlid;
      }
    });

    it('AbortSignal.abort("custom reason"): reason preserved through round-trip', async () => {
      const originalStableUlid = (globalThis as any)[STABLE_ULID];
      (globalThis as any)[STABLE_ULID] = () => '01ABORT0000000000005';
      try {
        const signal = AbortSignal.abort('custom reason');
        const ops: Promise<void>[] = [];

        const serialized = await dehydrateWorkflowArguments(
          signal,
          mockRunId,
          noEncryptionKey,
          ops
        );

        const hydrated = await hydrateWorkflowArguments(
          serialized,
          mockRunId,
          noEncryptionKey,
          vmGlobalThis
        );

        expect(hydrated.aborted).toBe(true);
        expect(hydrated.reason).toBe('custom reason');
      } finally {
        (globalThis as any)[STABLE_ULID] = originalStableUlid;
      }
    });
  });

  describe('step arguments (workflow → step)', () => {
    it('AbortController dehydrated with workflow reducers, hydrated with step revivers', async () => {
      try {
        // Create a controller stub as the workflow VM would produce:
        // a plain object with ABORT_STREAM_NAME/ABORT_HOOK_TOKEN symbols
        // and a signal property (mimicking workflow revivers output)
        const controller: any = {};
        controller[ABORT_STREAM_NAME] =
          'strm_01ABORT0000000000006_system_abort';
        controller[ABORT_HOOK_TOKEN] = 'abrt_01ABORT0000000000006';
        const signal: any = {};
        signal[ABORT_STREAM_NAME] = 'strm_01ABORT0000000000006_system_abort';
        signal[ABORT_HOOK_TOKEN] = 'abrt_01ABORT0000000000006';
        signal.aborted = false;
        signal.reason = undefined;
        controller.signal = signal;

        // The workflow reducers check instanceof, so we need the VM
        // to recognize these as AbortController/AbortSignal. Set up
        // simple constructors whose prototypes these objects inherit from.
        const origAC = vmGlobalThis.AbortController;
        const origAS = vmGlobalThis.AbortSignal;
        function FakeAC() {}
        function FakeAS() {}
        Object.setPrototypeOf(controller, FakeAC.prototype);
        Object.setPrototypeOf(signal, FakeAS.prototype);
        vmGlobalThis.AbortController = FakeAC;
        vmGlobalThis.AbortSignal = FakeAS;

        const serialized = await dehydrateStepArguments(
          controller,
          mockRunId,
          noEncryptionKey,
          vmGlobalThis
        );

        const ops: Promise<void>[] = [];
        const hydrated = await hydrateStepArguments(
          serialized,
          mockRunId,
          noEncryptionKey,
          ops
        );

        // Step revivers use reviveAbortController which creates a real AbortController
        expect(hydrated).toBeInstanceOf(AbortController);
        expect(hydrated.signal.aborted).toBe(false);
        expect((hydrated as any)[ABORT_STREAM_NAME]).toBe(
          'strm_01ABORT0000000000006_system_abort'
        );
        expect((hydrated as any)[ABORT_HOOK_TOKEN]).toBe(
          'abrt_01ABORT0000000000006'
        );

        vmGlobalThis.AbortController = origAC;
        vmGlobalThis.AbortSignal = origAS;
      } catch (e) {
        throw e;
      }
    });

    it('AbortSignal as standalone step argument', async () => {
      try {
        // Create a signal stub as the workflow VM would produce
        const signal: any = {};
        signal[ABORT_STREAM_NAME] = 'strm_01ABORT0000000000007_system_abort';
        signal[ABORT_HOOK_TOKEN] = 'abrt_01ABORT0000000000007';
        signal.aborted = false;
        signal.reason = undefined;

        const origAS = vmGlobalThis.AbortSignal;
        function FakeAS() {}
        Object.setPrototypeOf(signal, FakeAS.prototype);
        vmGlobalThis.AbortSignal = FakeAS;

        const serialized = await dehydrateStepArguments(
          signal,
          mockRunId,
          noEncryptionKey,
          vmGlobalThis
        );

        const ops: Promise<void>[] = [];
        const hydrated = await hydrateStepArguments(
          serialized,
          mockRunId,
          noEncryptionKey,
          ops
        );

        // Step revivers revive AbortSignal via reviveAbortController().signal
        expect(hydrated).toBeInstanceOf(AbortSignal);
        expect(hydrated.aborted).toBe(false);

        vmGlobalThis.AbortSignal = origAS;
      } catch (e) {
        throw e;
      }
    });

    it('stream reader triggers abort when abort payload arrives', async () => {
      // Override the global getWorld mock to return a readFromStream that
      // delivers an actual abort payload, verifying the stream reader in
      // reviveAbortController processes it correctly (not masked by the
      // default immediately-closed stream mock).
      const { getWorld } = await import('./runtime/world.js');
      const abortPayload = new TextEncoder().encode(
        JSON.stringify({ reason: 'stream-abort-reason' })
      );
      const readFromStreamMock = vi.fn().mockResolvedValue(
        new ReadableStream({
          start(c) {
            c.enqueue(abortPayload);
            c.close();
          },
        })
      );
      vi.mocked(getWorld).mockReturnValueOnce({
        writeToStream: vi.fn().mockResolvedValue(undefined),
        writeToStreamMulti: vi.fn().mockResolvedValue(undefined),
        closeStream: vi.fn().mockResolvedValue(undefined),
        readFromStream: readFromStreamMock,
        listStreamsByRunId: vi.fn().mockResolvedValue([]),
      } as any);

      try {
        const controller: any = {};
        controller[ABORT_STREAM_NAME] =
          'strm_01ABORT0000000000STRM_system_abort';
        controller[ABORT_HOOK_TOKEN] = 'abrt_01ABORT0000000000STRM';
        const signal: any = {};
        signal[ABORT_STREAM_NAME] = 'strm_01ABORT0000000000STRM_system_abort';
        signal[ABORT_HOOK_TOKEN] = 'abrt_01ABORT0000000000STRM';
        signal.aborted = false;
        signal.reason = undefined;
        controller.signal = signal;

        const origAC = vmGlobalThis.AbortController;
        const origAS = vmGlobalThis.AbortSignal;
        function FakeAC() {}
        function FakeAS() {}
        Object.setPrototypeOf(controller, FakeAC.prototype);
        Object.setPrototypeOf(signal, FakeAS.prototype);
        vmGlobalThis.AbortController = FakeAC;
        vmGlobalThis.AbortSignal = FakeAS;

        const serialized = await dehydrateStepArguments(
          controller,
          mockRunId,
          noEncryptionKey,
          vmGlobalThis
        );

        const ops: Promise<void>[] = [];
        const hydrated = await hydrateStepArguments(
          serialized,
          mockRunId,
          noEncryptionKey,
          ops
        );

        expect(hydrated).toBeInstanceOf(AbortController);
        expect(hydrated.signal.aborted).toBe(false);

        // Wait for the stream reader op to process the abort payload
        await Promise.all(ops);

        expect(hydrated.signal.aborted).toBe(true);
        expect(hydrated.signal.reason).toBe('stream-abort-reason');

        vmGlobalThis.AbortController = origAC;
        vmGlobalThis.AbortSignal = origAS;
      } catch (e) {
        throw e;
      }
    });
  });

  describe('step return value (step → workflow)', () => {
    it('AbortController dehydrated with step reducers, hydrated with workflow revivers', async () => {
      const originalStableUlid = (globalThis as any)[STABLE_ULID];
      (globalThis as any)[STABLE_ULID] = () => '01ABORT0000000000008';
      try {
        const controller = new AbortController();
        const ops: Promise<void>[] = [];

        const serialized = await dehydrateStepReturnValue(
          controller,
          mockRunId,
          noEncryptionKey,
          ops
        );

        // hydrateStepReturnValue uses workflow revivers (stubs)
        const hydrated = await hydrateStepReturnValue(
          serialized,
          mockRunId,
          noEncryptionKey,
          vmGlobalThis
        );

        expect(hydrated.signal).toBeDefined();
        expect(hydrated.signal.aborted).toBe(false);
        expect((hydrated as any)[ABORT_STREAM_NAME]).toBeDefined();
      } finally {
        (globalThis as any)[STABLE_ULID] = originalStableUlid;
      }
    });

    it('AbortSignal as standalone step return value', async () => {
      const originalStableUlid = (globalThis as any)[STABLE_ULID];
      (globalThis as any)[STABLE_ULID] = () => '01ABORT0000000000009';
      try {
        const controller = new AbortController();
        const signal = controller.signal;
        const ops: Promise<void>[] = [];

        const serialized = await dehydrateStepReturnValue(
          signal,
          mockRunId,
          noEncryptionKey,
          ops
        );

        const hydrated = await hydrateStepReturnValue(
          serialized,
          mockRunId,
          noEncryptionKey,
          vmGlobalThis
        );

        expect(hydrated.aborted).toBe(false);
        expect((hydrated as any)[ABORT_STREAM_NAME]).toBeDefined();
      } finally {
        (globalThis as any)[STABLE_ULID] = originalStableUlid;
      }
    });
  });

  describe('nested and compound structures', () => {
    it('AbortController nested in object: { ctrl: new AbortController() }', async () => {
      const originalStableUlid = (globalThis as any)[STABLE_ULID];
      (globalThis as any)[STABLE_ULID] = () => '01ABORT000000000000A';
      try {
        const controller = new AbortController();
        const data = { ctrl: controller, extra: 'hello' };
        const ops: Promise<void>[] = [];

        const serialized = await dehydrateWorkflowArguments(
          data,
          mockRunId,
          noEncryptionKey,
          ops
        );

        const hydrated = (await hydrateWorkflowArguments(
          serialized,
          mockRunId,
          noEncryptionKey,
          vmGlobalThis
        )) as { ctrl: any; extra: string };

        expect(hydrated.ctrl.signal).toBeDefined();
        expect(hydrated.ctrl.signal.aborted).toBe(false);
        expect((hydrated.ctrl as any)[ABORT_STREAM_NAME]).toBeDefined();
        expect(hydrated.extra).toBe('hello');
      } finally {
        (globalThis as any)[STABLE_ULID] = originalStableUlid;
      }
    });

    it('array of controllers: [ctrl1, ctrl2] get distinct stream names', async () => {
      let callCount = 0;
      const originalStableUlid = (globalThis as any)[STABLE_ULID];
      (globalThis as any)[STABLE_ULID] = () => {
        callCount++;
        return `01ABORT00000000000${callCount.toString().padStart(2, '0')}`;
      };
      try {
        const ctrl1 = new AbortController();
        const ctrl2 = new AbortController();
        const ops: Promise<void>[] = [];

        const serialized = await dehydrateWorkflowArguments(
          [ctrl1, ctrl2],
          mockRunId,
          noEncryptionKey,
          ops
        );

        const hydrated = (await hydrateWorkflowArguments(
          serialized,
          mockRunId,
          noEncryptionKey,
          vmGlobalThis
        )) as any[];

        // Both should have signal properties (workflow stubs)
        expect(hydrated[0].signal).toBeDefined();
        expect(hydrated[1].signal).toBeDefined();

        // They should have distinct stream names
        const name1 = (hydrated[0] as any)[ABORT_STREAM_NAME];
        const name2 = (hydrated[1] as any)[ABORT_STREAM_NAME];
        expect(name1).toBeDefined();
        expect(name2).toBeDefined();
        expect(name1).not.toBe(name2);
      } finally {
        (globalThis as any)[STABLE_ULID] = originalStableUlid;
      }
    });

    it('same controller serialized twice reuses the same stream name (WeakMap dedup)', async () => {
      const originalStableUlid = (globalThis as any)[STABLE_ULID];
      (globalThis as any)[STABLE_ULID] = () => '01ABORT000000000000D';
      try {
        const controller = new AbortController();
        const ops: Promise<void>[] = [];

        // Serialize the same controller in two different positions
        const serialized = await dehydrateWorkflowArguments(
          { a: controller, b: controller },
          mockRunId,
          noEncryptionKey,
          ops
        );

        const hydrated = (await hydrateWorkflowArguments(
          serialized,
          mockRunId,
          noEncryptionKey,
          vmGlobalThis
        )) as { a: any; b: any };

        // Both should share the same stream name (dedup via symbol on the original)
        const nameA = (hydrated.a as any)[ABORT_STREAM_NAME];
        const nameB = (hydrated.b as any)[ABORT_STREAM_NAME];
        expect(nameA).toBeDefined();
        expect(nameA).toBe(nameB);
      } finally {
        (globalThis as any)[STABLE_ULID] = originalStableUlid;
      }
    });
  });

  describe('integration with Request', () => {
    it('Request with workflow-managed signal preserves signal through step hydration', async () => {
      const originalStableUlid = (globalThis as any)[STABLE_ULID];
      (globalThis as any)[STABLE_ULID] = () => '01ABORT000000000000E';
      try {
        // The Request constructor copies the signal internally, so symbols
        // set on the original controller.signal won't appear on request.signal.
        // To test the Request+signal serialization path, set the symbol
        // directly on the Request's own signal after construction.
        const controller = new AbortController();
        controller.abort('request cancelled');
        const request = new Request('https://example.com/api', {
          method: 'POST',
          signal: controller.signal,
        });
        (request.signal as any)[ABORT_STREAM_NAME] =
          'strm_01ABORT000000000000E_system_abort';
        (request.signal as any)[ABORT_HOOK_TOKEN] = 'abrt_01ABORT000000000000E';
        const ops: Promise<void>[] = [];

        const serialized = await dehydrateWorkflowArguments(
          request,
          mockRunId,
          noEncryptionKey,
          ops
        );

        const hydrated = (await hydrateStepArguments(
          serialized,
          mockRunId,
          noEncryptionKey,
          ops
        )) as Request;

        expect(hydrated).toBeInstanceOf(Request);
        expect(hydrated.url).toBe('https://example.com/api');
        expect(hydrated.method).toBe('POST');
        expect(hydrated.signal).toBeDefined();
        expect(hydrated.signal.aborted).toBe(true);
        expect(hydrated.signal.reason).toBe('request cancelled');
      } finally {
        (globalThis as any)[STABLE_ULID] = originalStableUlid;
      }
    });

    it('Request with plain (non-workflow) signal does not serialize the signal', async () => {
      const controller = new AbortController();
      controller.abort('user timeout');
      const request = new Request('https://example.com/api', {
        method: 'GET',
        signal: controller.signal,
      });
      const ops: Promise<void>[] = [];

      const serialized = await dehydrateWorkflowArguments(
        request,
        mockRunId,
        noEncryptionKey,
        ops
      );

      const hydrated = (await hydrateStepArguments(
        serialized,
        mockRunId,
        noEncryptionKey,
        ops
      )) as Request;

      expect(hydrated).toBeInstanceOf(Request);
      expect(hydrated.url).toBe('https://example.com/api');
      expect(hydrated.method).toBe('GET');
      // Plain signals are not serialized — the hydrated Request gets a fresh default signal
      expect(hydrated.signal.aborted).toBe(false);
    });
  });

  describe('encryption', () => {
    const testKeyRaw = new Uint8Array([
      0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
      0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
      0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
    ]);
    let testKey: CryptoKey;
    beforeAll(async () => {
      testKey = await importKey(testKeyRaw);
    });

    it('AbortController round-trip with encryption enabled', async () => {
      const originalStableUlid = (globalThis as any)[STABLE_ULID];
      (globalThis as any)[STABLE_ULID] = () => '01ABORT000000000000F';
      try {
        const controller = new AbortController();
        const ops: Promise<void>[] = [];

        const encrypted = await dehydrateWorkflowArguments(
          controller,
          mockRunId,
          testKey,
          ops,
          globalThis,
          false
        );

        // Should have 'encr' prefix
        expect(encrypted).toBeInstanceOf(Uint8Array);
        const prefix = new TextDecoder().decode(
          (encrypted as Uint8Array).subarray(0, 4)
        );
        expect(prefix).toBe('encr');

        const decrypted = await hydrateWorkflowArguments(
          encrypted,
          mockRunId,
          testKey,
          vmGlobalThis,
          {}
        );

        expect(decrypted.signal).toBeDefined();
        expect(decrypted.signal.aborted).toBe(false);
        expect((decrypted as any)[ABORT_STREAM_NAME]).toBeDefined();
      } finally {
        (globalThis as any)[STABLE_ULID] = originalStableUlid;
      }
    });

    it('AbortSignal round-trip with encryption enabled', async () => {
      const originalStableUlid = (globalThis as any)[STABLE_ULID];
      (globalThis as any)[STABLE_ULID] = () => '01ABORT000000000000G';
      try {
        const signal = AbortSignal.abort('encrypted reason');
        const ops: Promise<void>[] = [];

        const encrypted = await dehydrateWorkflowArguments(
          signal,
          mockRunId,
          testKey,
          ops,
          globalThis,
          false
        );

        // Should have 'encr' prefix
        expect(encrypted).toBeInstanceOf(Uint8Array);
        const prefix = new TextDecoder().decode(
          (encrypted as Uint8Array).subarray(0, 4)
        );
        expect(prefix).toBe('encr');

        const decrypted = await hydrateWorkflowArguments(
          encrypted,
          mockRunId,
          testKey,
          vmGlobalThis,
          {}
        );

        expect(decrypted.aborted).toBe(true);
        expect(decrypted.reason).toBe('encrypted reason');
      } finally {
        (globalThis as any)[STABLE_ULID] = originalStableUlid;
      }
    });
  });
});