@outputai/core 0.14.0 → 0.14.1-next.1ec4416.0

package/src/helpers/error_serializer.spec.js

@@ -1,479 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import {
-  flattenPrototypeChain,
-  isDomException,
-  resolveErrorName,
-  serializeError,
-  truncateArray,
-  truncateString
-} from './error_serializer.js';
-
-const redactUrlMock = vi.hoisted( () => vi.fn().mockReturnValue( '[Redacted URL]' ) );
-const isUrlMock = vi.hoisted( () => vi.fn().mockReturnValue( false ) );
-
-vi.mock( './redact.js', () => ( { redactUrl: redactUrlMock } ) );
-vi.mock( './string.js', () => ( { isUrl: isUrlMock } ) );
-
-describe( 'error serializer helpers', () => {
-  describe( 'truncateString', () => {
-    it( 'preserves values within the limit and marks omitted characters', () => {
-      expect( truncateString( 'exact', 5 ) ).toBe( 'exact' );
-      expect( truncateString( 'longer', 5 ) ).toBe( 'longe... [1 more characters omitted]' );
-    } );
-  } );
-
-  describe( 'truncateArray', () => {
-    it( 'preserves values within the limit and marks omitted items without mutating the source', () => {
-      const exact = [ 1, 2 ];
-      const long = [ 1, 2, 3 ];
-
-      expect( truncateArray( exact, 2 ) ).toBe( exact );
-      expect( truncateArray( long, 2 ) ).toEqual( [ 1, 2, '... [1 more items omitted]' ] );
-      expect( long ).toEqual( [ 1, 2, 3 ] );
-    } );
-  } );
-
-  describe( 'flattenPrototypeChain', () => {
-    it( 'returns child-first prototypes and honors the depth limit', () => {
-      const grandparent = { grandparent: true };
-      const parent = Object.create( grandparent );
-      const child = Object.create( parent );
-
-      expect( flattenPrototypeChain( child, 0, [], 2 ) ).toEqual( [ child, parent ] );
-      expect( flattenPrototypeChain( child, 0, [], 3 ) ).toEqual( [ child, parent, grandparent ] );
-    } );
-  } );
-
-  describe( 'isDomException', () => {
-    afterEach( () => {
-      vi.unstubAllGlobals();
-    } );
-
-    it( 'detects DOMExceptions, including abort reasons, and rejects lookalikes', () => {
-      expect( isDomException( new DOMException( 'aborted', 'AbortError' ) ) ).toBe( true );
-      expect( isDomException( AbortSignal.abort().reason ) ).toBe( true );
-      expect( isDomException( new Error( 'aborted' ) ) ).toBe( false );
-      expect( isDomException( { name: 'AbortError', code: 20 } ) ).toBe( false );
-      expect( isDomException( undefined ) ).toBe( false );
-      expect( isDomException( null ) ).toBe( false );
-    } );
-
-    it( 'detects DOMExceptions where the global is unavailable, as in the workflow sandbox', () => {
-      const error = new DOMException( 'aborted', 'AbortError' );
-      vi.stubGlobal( 'DOMException', undefined );
-
-      expect( isDomException( error ) ).toBe( true );
-      expect( serializeError( error, { dropKeys: [ 'stack' ] } ) ).toEqual( {
-        name: 'AbortError',
-        message: 'aborted',
-        code: 20
-      } );
-    } );
-  } );
-
-  describe( 'resolveErrorName', () => {
-    it( 'uses explicit, inherited, and constructor names in precedence order', () => {
-      class ConstructorNamedError extends Error {}
-      class InheritedNamedError extends Error {}
-      InheritedNamedError.prototype.name = 'InheritedName';
-      class ExplicitlyNamedError extends Error {
-        name = 'ExplicitName';
-      }
-      class ExplicitlyGenericError extends Error {
-        name = 'Error';
-      }
-
-      expect( resolveErrorName( new ConstructorNamedError() ) ).toBe( 'ConstructorNamedError' );
-      expect( resolveErrorName( new InheritedNamedError() ) ).toBe( 'InheritedName' );
-      expect( resolveErrorName( new ExplicitlyNamedError() ) ).toBe( 'ExplicitName' );
-      expect( resolveErrorName( new ExplicitlyGenericError() ) ).toBe( 'Error' );
-      expect( resolveErrorName( new Error() ) ).toBe( 'Error' );
-      expect( resolveErrorName( { name: 'ObjectName' } ) ).toBeUndefined();
-    } );
-
-    it( 'returns undefined when an explicit name getter throws', () => {
-      const error = new Error();
-      Object.defineProperty( error, 'name', {
-        get: () => {
-          throw new Error( 'name unavailable' );
-        }
-      } );
-
-      expect( resolveErrorName( error ) ).toBeUndefined();
-    } );
-  } );
-} );
-
-describe( 'serializeError', () => {
-  it( 'serializes descriptors and skips unusable properties', () => {
-    const error = new Error( 'step failed' );
-    Object.defineProperties( error, {
-      code: { value: 'ESTEP' },
-      hidden: { value: 'available for debugging' },
-      computed: { get: () => `computed from ${error.message}` },
-      broken: {
-        get: () => {
-          throw new Error( 'getter failed' );
-        }
-      },
-      callback: { value: () => 'not serializable' },
-      skipped: { value: undefined },
-      symbol: { value: Symbol( 'debug' ) },
-      __proto__: { value: { unsafe: true } }
-    } );
-    error.nullable = null;
-
-    const serialized = serializeError( error, { dropKeys: [ 'stack' ] } );
-
-    expect( serialized ).toEqual( {
-      name: 'Error',
-      message: 'step failed',
-      code: 'ESTEP',
-      hidden: 'available for debugging',
-      computed: 'computed from step failed',
-      nullable: null,
-      symbol: 'Symbol(debug)'
-    } );
-    expect( Object.hasOwn( serialized, '__proto__' ) ).toBe( false );
-  } );
-
-  it( 'applies custom dropped keys recursively and across prototypes', () => {
-    class DebugError extends Error {}
-    DebugError.prototype.internal = 'prototype value';
-
-    const cause = new DebugError( 'cause failed' );
-    cause.context = { internal: 'nested cause value', visible: 'cause context' };
-    const error = new DebugError( 'request failed', { cause } );
-    error.internal = 'instance value';
-    error.context = { internal: 'nested root value', visible: 'root context' };
-
-    const serialized = serializeError( error, { dropKeys: [ 'internal', 'stack' ] } );
-
-    expect( serialized ).not.toHaveProperty( 'internal' );
-    expect( serialized.context ).toEqual( { visible: 'root context' } );
-    expect( serialized.cause ).not.toHaveProperty( 'internal' );
-    expect( serialized.cause.context ).toEqual( { visible: 'cause context' } );
-  } );
-
-  it( 'merges prototype properties child-first without invoking overridden getters', () => {
-    const overriddenGetter = vi.fn( () => 'base' );
-    class BaseFailure extends Error {}
-    Object.defineProperties( BaseFailure.prototype, {
-      baseProperty: { value: 'base' },
-      overridden: { get: overriddenGetter }
-    } );
-    class RequestFailure extends BaseFailure {}
-    RequestFailure.prototype.requestProperty = 'request';
-
-    const error = new RequestFailure( 'request failed' );
-    Object.defineProperty( error, 'overridden', { value: 'instance' } );
-
-    expect( serializeError( error, { dropKeys: [ 'stack' ] } ) ).toEqual( {
-      name: 'RequestFailure',
-      message: 'request failed',
-      overridden: 'instance',
-      requestProperty: 'request',
-      baseProperty: 'base'
-    } );
-    expect( overriddenGetter ).not.toHaveBeenCalled();
-  } );
-
-  it( 'recursively serializes causes, nested objects, and arrays', () => {
-    const databaseError = new Error( 'database unavailable' );
-    databaseError.code = 'ECONNREFUSED';
-    const serviceError = new Error( 'service failed', { cause: databaseError } );
-    serviceError.context = {
-      attempts: [
-        { number: 1, metadata: { retryable: true } },
-        { number: 2, metadata: null }
-      ]
-    };
-
-    expect( serializeError( serviceError, { dropKeys: [ 'stack' ] } ) ).toEqual( {
-      name: 'Error',
-      message: 'service failed',
-      cause: {
-        name: 'Error',
-        message: 'database unavailable',
-        code: 'ECONNREFUSED'
-      },
-      context: {
-        attempts: [
-          { number: 1, metadata: { retryable: true } },
-          { number: 2, metadata: null }
-        ]
-      }
-    } );
-  } );
-
-  it( 'returns primitives as-is', () => {
-    expect( serializeError( undefined ) ).toBeUndefined();
-    expect( serializeError( null ) ).toBeNull();
-    expect( serializeError( 42 ) ).toBe( 42 );
-    expect( serializeError( true ) ).toBe( true );
-  } );
-
-  it( 'serializes Date values as ISO strings and marks invalid dates', () => {
-    expect( serializeError( new Date( '2026-07-22T16:30:00.000Z' ) ) ).toBe( '2026-07-22T16:30:00.000Z' );
-    expect( serializeError( new Date( 'foo' ) ) ).toBe( '[Invalid Date]' );
-  } );
-
-  it( 'serializes RegExp values with toString', () => {
-    expect( serializeError( /request-\d+/gi ) ).toBe( '/request-\\d+/gi' );
-  } );
-
-  it( 'serializes DOMException values without the legacy prototype constants', () => {
-    const error = new DOMException( 'Cancelled by caller', 'AbortError' );
-
-    expect( serializeError( error ) ).toEqual( {
-      name: 'AbortError',
-      message: 'Cancelled by caller',
-      code: 20,
-      stack: expect.stringContaining( 'AbortError: Cancelled by caller' )
-    } );
-    expect( serializeError( error, { dropKeys: [ /stack/ ] } ) ).toEqual( {
-      name: 'AbortError',
-      message: 'Cancelled by caller',
-      code: 20
-    } );
-  } );
-
-  it( 'marks circular DOMException fields and drops properties outside the allowed list', () => {
-    const error = new DOMException( 'aborted', 'AbortError' );
-    Object.defineProperty( error, 'message', { value: error, enumerable: true } );
-    error.attempt = 2;
-
-    expect( serializeError( { reason: error, sibling: 'preserved' }, { dropKeys: [ 'stack' ] } ) ).toEqual( {
-      reason: { name: 'AbortError', message: '[Circular Reference]', code: 20 },
-      sibling: 'preserved'
-    } );
-  } );
-
-  it( 'serializes bigint values with an n suffix', () => {
-    expect( serializeError( 42n ) ).toBe( '42n' );
-    expect( serializeError( -42n ) ).toBe( '-42n' );
-  } );
-
-  it( 'marks bigints that would exceed the string length budget', () => {
-    const maxDigits = 16_383; // MAX_STRING_LEN - 1
-    const tooLarge = 10n ** BigInt( maxDigits );
-
-    expect( serializeError( tooLarge - 1n ) ).toBe( `${tooLarge - 1n}n` );
-    expect( serializeError( tooLarge ) ).toBe( '[BigInt too large]' );
-    expect( serializeError( -tooLarge ) ).toBe( '[BigInt too large]' );
-    expect( serializeError( 10n ** 20_000n ) ).toBe( '[BigInt too large]' );
-  } );
-
-  it( 'serializes symbol values', () => {
-    expect( serializeError( Symbol( 'request' ) ) ).toBe( 'Symbol(request)' );
-  } );
-
-  it( 'serializes functions by name', () => {
-    function namedFunction() {}
-    expect( serializeError( namedFunction ) ).toBe( '[Function: namedFunction]' );
-    expect( serializeError( () => undefined ) ).toBe( '[Function: (anonymous)]' );
-  } );
-
-  it( 'serializes ArrayBuffers and views as type and size without dumping contents', () => {
-    expect( serializeError( new Uint16Array( [ 1, 2 ] ) ) ).toBe( 'Uint16Array(2)' );
-    expect( serializeError( Buffer.from( [ 1, 2 ] ) ) ).toBe( 'Buffer(2)' );
-    expect( serializeError( new DataView( new ArrayBuffer( 8 ) ) ) ).toBe( 'DataView(8)' );
-    expect( serializeError( new ArrayBuffer( 16 ) ) ).toBe( 'ArrayBuffer(16)' );
-  } );
-
-  it( 'redacts URL strings and URL instances with redactUrl', () => {
-    const stringUrl = 'https://user:password@example.com/models?model=gpt-5&token=secret#debug';
-    const url = new URL( 'ftp://user:password@example.com/file.txt?download=true#details' );
-    redactUrlMock.mockClear();
-    isUrlMock.mockClear();
-    isUrlMock.mockReturnValueOnce( true );
-
-    expect( serializeError( {
-      stringUrl,
-      url
-    } ) ).toEqual( {
-      stringUrl: '[Redacted URL]',
-      url: '[Redacted URL]'
-    } );
-    expect( isUrlMock ).toHaveBeenCalledOnce();
-    expect( isUrlMock ).toHaveBeenCalledWith( stringUrl );
-    expect( redactUrlMock ).toHaveBeenCalledTimes( 2 );
-    expect( redactUrlMock ).toHaveBeenNthCalledWith( 1, stringUrl );
-    expect( redactUrlMock ).toHaveBeenNthCalledWith( 2, url );
-  } );
-
-  it( 'truncates string values and property names', () => {
-    const longValue = 'v'.repeat( 16_385 );
-    const sharedKeyPrefix = 'k'.repeat( 256 );
-
-    expect( serializeError( {
-      longValue,
-      [`${sharedKeyPrefix}a`]: 'first',
-      [`${sharedKeyPrefix}b`]: 'second'
-    } ) ).toEqual( {
-      longValue: `${'v'.repeat( 16_384 )}... [1 more characters omitted]`,
-      [`${sharedKeyPrefix}... [1 more characters omitted]`]: 'first'
-    } );
-  } );
-
-  it( 'limits arrays, maps, and sets while recursively serializing their values', () => {
-    const exactArray = Array.from( { length: 50 }, ( _, index ) => index );
-    const longArray = Array.from( { length: 52 }, ( _, index ) => index );
-    const longMap = new Map( Array.from( { length: 51 }, ( _, index ) => [ `key-${index}`, BigInt( index ) ] ) );
-    const longSet = new Set( Array.from( { length: 52 }, ( _, index ) => BigInt( index ) ) );
-
-    expect( serializeError( exactArray ) ).toEqual( exactArray );
-    expect( serializeError( longArray ) ).toEqual( [ ...exactArray, '... [2 more items omitted]' ] );
-
-    const serializedMap = serializeError( longMap );
-    expect( serializedMap ).toHaveLength( 51 );
-    expect( serializedMap[0] ).toEqual( [ 'key-0', '0n' ] );
-    expect( serializedMap.at( -1 ) ).toBe( '... [1 more items omitted]' );
-
-    const serializedSet = serializeError( longSet );
-    expect( serializedSet ).toHaveLength( 51 );
-    expect( serializedSet[0] ).toBe( '0n' );
-    expect( serializedSet.at( -1 ) ).toBe( '... [2 more items omitted]' );
-  } );
-
-  it( 'globally limits object properties while prioritizing own properties', () => {
-    const exactProperties = Object.fromEntries( Array.from( { length: 50 }, ( _, index ) => [ `property-${index}`, index ] ) );
-    expect( serializeError( exactProperties ) ).toEqual( exactProperties );
-
-    const prototype = { inherited: 'omitted' };
-    const instance = Object.assign(
-      Object.create( prototype ),
-      Object.fromEntries( Array.from( { length: 50 }, ( _, index ) => [ `own-${index}`, index ] ) )
-    );
-    const serialized = serializeError( instance );
-
-    expect( Object.keys( serialized ) ).toHaveLength( 51 );
-    expect( serialized['own-49'] ).toBe( 49 );
-    expect( serialized ).not.toHaveProperty( 'inherited' );
-    expect( serialized['...'] ).toBe( '[Maximum Object Properties Reached]' );
-  } );
-
-  it( 'serializes the resolved error name instead of returning it raw', () => {
-    const circular = new Error( 'boom' );
-    circular.name = circular;
-    const oversized = new Error( 'boom' );
-    oversized.name = 'n'.repeat( 16_385 );
-
-    expect( serializeError( circular, { dropKeys: [ 'stack' ] } ).name ).toBe( '[Circular Reference]' );
-    expect( serializeError( oversized, { dropKeys: [ 'stack' ] } ).name )
-      .toBe( `${'n'.repeat( 16_384 )}... [1 more characters omitted]` );
-  } );
-
-  it( 'retains error identity when properties reach the object limit', () => {
-    class DetailedError extends Error {}
-    const error = new DetailedError( 'failed' );
-    Object.assign( error, Object.fromEntries( Array.from( { length: 50 }, ( _, index ) => [ `field-${index}`, index ] ) ) );
-
-    const serialized = serializeError( error, { dropKeys: [ 'stack' ] } );
-
-    expect( serialized.name ).toBe( 'DetailedError' );
-    expect( serialized.message ).toBe( 'failed' );
-    expect( serialized['...'] ).toBe( '[Maximum Object Properties Reached]' );
-  } );
-
-  it( 'recursively excludes sensitive and internal properties while retaining similarly named diagnostics', () => {
-    const value = {
-      failure: { internal: 'Temporal protobuf' },
-      originalFailure: { details: 'Nexus failure' },
-      $type: { parent: 'protobuf reflection graph' },
-      request: { body: 'private request' },
-      response: { body: 'private response' },
-      headers: { Authorization: 'Bearer secret' },
-      Authorization: 'Bearer secret',
-      RequestBodyValues: { prompt: 'private prompt' },
-      RESPONSE_HEADERS: { Cookie: 'private cookie' },
-      APIKey: 'private key',
-      AccessToken: 'private token',
-      PASSWORD: 'private password',
-      Credential: 'private credential',
-      keyboard: 'preserved',
-      tokenCount: 42,
-      passwordPolicy: 'preserved',
-      secretCount: 1,
-      nested: {
-        Cookie: 'private cookie',
-        code: 'EFAILED'
-      }
-    };
-
-    expect( serializeError( value ) ).toEqual( {
-      keyboard: 'preserved',
-      tokenCount: 42,
-      passwordPolicy: 'preserved',
-      secretCount: 1,
-      nested: { code: 'EFAILED' }
-    } );
-  } );
-
-  it( 'includes stacks by default and supports dropping them recursively', () => {
-    const cause = new Error( 'database unavailable' );
-    const error = new Error( 'service failed', { cause } );
-
-    const withStacks = serializeError( error );
-    const withoutStacks = serializeError( error, { dropKeys: [ 'stack' ] } );
-
-    expect( withStacks.stack ).toContain( 'Error: service failed' );
-    expect( withStacks.cause.stack ).toContain( 'Error: database unavailable' );
-    expect( withoutStacks ).not.toHaveProperty( 'stack' );
-    expect( withoutStacks.cause ).not.toHaveProperty( 'stack' );
-  } );
-
-  it( 'marks circular references but serializes shared sibling values independently', () => {
-    const shared = { code: 'ESHARED' };
-    const objectCycle = {};
-    objectCycle.self = objectCycle;
-    const arrayCycle = [];
-    arrayCycle.push( arrayCycle );
-    const mapCycle = new Map();
-    mapCycle.set( 'self', mapCycle );
-    const setCycle = new Set();
-    setCycle.add( setCycle );
-
-    expect( serializeError( {
-      objectCycle,
-      arrayCycle,
-      mapCycle,
-      setCycle,
-      first: shared,
-      second: shared
-    } ) ).toEqual( {
-      objectCycle: { self: '[Circular Reference]' },
-      arrayCycle: [ '[Circular Reference]' ],
-      mapCycle: [ [ 'self', '[Circular Reference]' ] ],
-      setCycle: [ '[Circular Reference]' ],
-      first: { code: 'ESHARED' },
-      second: { code: 'ESHARED' }
-    } );
-  } );
-
-  it( 'marks values beyond the maximum recursive depth', () => {
-    const createNestedValue = depth => depth === 0 ? {} : { child: createNestedValue( depth - 1 ) };
-    const root = createNestedValue( 10 );
-
-    expect(
-      Array.from( { length: 9 } ).reduce( value => value.child, serializeError( root ) ).child
-    ).toBe( '[Maximum Depth Reached]' );
-  } );
-
-  it( 'marks values after the total serialization limit is reached', () => {
-    const value = Array.from(
-      { length: 50 },
-      () => Array.from( { length: 50 }, ( _, index ) => index )
-    );
-
-    expect( JSON.stringify( serializeError( value ) ) ).toContain( '[Serialization Limit Reached]' );
-  } );
-
-  it( 'returns an unserializable marker for exotic values that throw during reflection', () => {
-    const { proxy, revoke } = Proxy.revocable( {}, {} );
-    revoke();
-
-    expect( serializeError( proxy ) ).toBe( '[Unserializable]' );
-    expect( serializeError( { nested: proxy } ) ).toEqual( { nested: '[Unserializable]' } );
-  } );
-} );

package/src/helpers/errors.spec.js

@@ -1,189 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { inheritsFromAnyNamedType, rehydrateError } from './errors.js';
-
-describe( 'inheritsFromAnyNamedType', () => {
-  class BaseFailure extends Error {}
-  class DomainFailure extends BaseFailure {}
-  class RequestFailure extends DomainFailure {}
-  class UnrelatedFailure extends Error {}
-
-  it( 'matches exact, parent, and grandparent constructor names', () => {
-    const error = new RequestFailure( 'request failed' );
-
-    expect( inheritsFromAnyNamedType( error, [ 'RequestFailure' ] ) ).toBe( true );
-    expect( inheritsFromAnyNamedType( error, [ 'DomainFailure' ] ) ).toBe( true );
-    expect( inheritsFromAnyNamedType( error, [ 'BaseFailure' ] ) ).toBe( true );
-    expect( inheritsFromAnyNamedType( error, [ 'OtherFailure', 'BaseFailure' ] ) ).toBe( true );
-  } );
-
-  it( 'does not match unrelated or descendant constructor names', () => {
-    expect( inheritsFromAnyNamedType( new RequestFailure(), [ 'UnrelatedFailure' ] ) ).toBe( false );
-    expect( inheritsFromAnyNamedType( new BaseFailure(), [ 'RequestFailure' ] ) ).toBe( false );
-    expect( inheritsFromAnyNamedType( new UnrelatedFailure(), [ 'BaseFailure' ] ) ).toBe( false );
-  } );
-
-  it( 'ignores a spoofed own constructor property', () => {
-    const error = new RequestFailure();
-    Object.defineProperty( error, 'constructor', {
-      value: { name: 'SpoofedFailure' }
-    } );
-
-    expect( inheritsFromAnyNamedType( error, [ 'SpoofedFailure' ] ) ).toBe( false );
-    expect( inheritsFromAnyNamedType( error, [ 'RequestFailure' ] ) ).toBe( true );
-  } );
-
-  it( 'rejects empty names and invalid values without false positives', () => {
-    const unnamedConstructor = function NamedConstructor() {};
-    Object.defineProperty( unnamedConstructor, 'name', { value: '' } );
-    const value = Object.create( { constructor: unnamedConstructor } );
-
-    expect( inheritsFromAnyNamedType( value, [ '', undefined ] ) ).toBe( false );
-    expect( inheritsFromAnyNamedType( value, [] ) ).toBe( false );
-    expect( inheritsFromAnyNamedType( null, [ 'BaseFailure' ] ) ).toBe( false );
-    expect( inheritsFromAnyNamedType( 'failure', [ 'String' ] ) ).toBe( false );
-  } );
-} );
-
-describe( 'rehydrateError', () => {
-  it( 'returns the same Error instance when given an Error', () => {
-    const original = new Error( 'already an error' );
-    original.name = 'FatalError';
-
-    expect( rehydrateError( original ) ).toBe( original );
-  } );
-
-  it( 'rebuilds a plain serialized error with name and message', () => {
-    const result = rehydrateError( {
-      name: 'FatalError',
-      message: 'workflow failed'
-    } );
-
-    expect( result ).toBeInstanceOf( Error );
-    expect( result.name ).toBe( 'FatalError' );
-    expect( result.message ).toBe( 'workflow failed' );
-    expect( result.stack ).toBeUndefined();
-  } );
-
-  it( 'restores stack when present on the serialized object', () => {
-    const result = rehydrateError( {
-      name: 'Error',
-      message: 'boom',
-      stack: 'Error: boom\n    at workflow.js:1:1'
-    } );
-
-    expect( result.stack ).toBe( 'Error: boom\n    at workflow.js:1:1' );
-  } );
-
-  it( 'copies additional enumerable properties', () => {
-    const result = rehydrateError( {
-      name: 'HTTPError',
-      message: 'bad request',
-      status: 400,
-      code: 'BAD_REQUEST'
-    } );
-
-    expect( result.status ).toBe( 400 );
-    expect( result.code ).toBe( 'BAD_REQUEST' );
-  } );
-
-  it( 'recursively rehydrates a plain-object cause', () => {
-    const result = rehydrateError( {
-      name: 'ActivityFailure',
-      message: 'Activity task failed',
-      cause: {
-        name: 'ApplicationFailure',
-        message: 'root failure',
-        cause: {
-          name: 'ValidationError',
-          message: 'invalid input'
-        }
-      }
-    } );
-
-    expect( result.cause ).toBeInstanceOf( Error );
-    expect( result.cause.name ).toBe( 'ApplicationFailure' );
-    expect( result.cause.message ).toBe( 'root failure' );
-    expect( result.cause.cause ).toBeInstanceOf( Error );
-    expect( result.cause.cause.name ).toBe( 'ValidationError' );
-    expect( result.cause.cause.message ).toBe( 'invalid input' );
-  } );
-
-  it( 'leaves a non-object cause unchanged', () => {
-    const result = rehydrateError( {
-      name: 'Error',
-      message: 'outer',
-      cause: 'string cause'
-    } );
-
-    expect( result.cause ).toBe( 'string cause' );
-  } );
-
-  it( 'returns an empty Error for null and undefined without throwing', () => {
-    const fromNull = rehydrateError( null );
-    const fromUndefined = rehydrateError( undefined );
-
-    expect( fromNull ).toBeInstanceOf( Error );
-    expect( fromNull.message ).toBe( '' );
-    expect( fromNull.stack ).toBeUndefined();
-
-    expect( fromUndefined ).toBeInstanceOf( Error );
-    expect( fromUndefined.message ).toBe( '' );
-    expect( fromUndefined.stack ).toBeUndefined();
-  } );
-
-  it.each( [
-    [ 'string', 'boom', 'boom' ],
-    [ 'number', 42, '42' ],
-    [ 'boolean', true, 'true' ],
-    [ 'bigint', 1n, '1' ],
-    [ 'symbol', Symbol( 'x' ), 'Symbol(x)' ],
-    [ 'named function', function named() {}, 'function named() {}' ],
-    [ 'arrow function', () => {}, '() => {}' ]
-  ] )( 'stringifies a %s into Error.message', ( _label, input, message ) => {
-    const result = rehydrateError( input );
-
-    expect( result ).toBeInstanceOf( Error );
-    expect( result.message ).toBe( message );
-    expect( result.stack ).toBeUndefined();
-  } );
-
-  it( 'copies enumerable array indexes onto an empty Error', () => {
-    const result = rehydrateError( [ 'a', 'b' ] );
-
-    expect( result ).toBeInstanceOf( Error );
-    expect( result.message ).toBe( '' );
-    expect( result.stack ).toBeUndefined();
-    expect( result[0] ).toBe( 'a' );
-    expect( result[1] ).toBe( 'b' );
-  } );
-
-  it( 'returns an empty Error for RegExp and Date (no enumerable own props)', () => {
-    const fromRegexp = rehydrateError( /foo/gi );
-    const fromDate = rehydrateError( new Date( '2020-01-01T00:00:00.000Z' ) );
-
-    expect( fromRegexp ).toBeInstanceOf( Error );
-    expect( fromRegexp.message ).toBe( '' );
-    expect( fromRegexp.stack ).toBeUndefined();
-
-    expect( fromDate ).toBeInstanceOf( Error );
-    expect( fromDate.message ).toBe( '' );
-    expect( fromDate.stack ).toBeUndefined();
-  } );
-
-  it( 'copies enumerable own props from a custom class instance', () => {
-    class Widget {
-      constructor() {
-        this.x = 1;
-        this.name = 'WidgetError';
-      }
-    }
-
-    const result = rehydrateError( new Widget() );
-
-    expect( result ).toBeInstanceOf( Error );
-    expect( result.message ).toBe( '' );
-    expect( result.stack ).toBeUndefined();
-    expect( result.x ).toBe( 1 );
-    expect( result.name ).toBe( 'WidgetError' );
-  } );
-} );