@outputai/core 0.13.1-next.318b2e6.0 → 0.13.1-next.38c895c.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/core",
-  "version": "0.13.1-next.318b2e6.0",
+  "version": "0.13.1-next.38c895c.0",
   "description": "The core module of the output framework",
   "type": "module",
   "engines": {

package/src/helpers/error_serializer.js

@@ -61,6 +61,18 @@ export const flattenPrototypeChain = ( target, depth = 0, result = [], maxDepth
   !target || depth >= maxDepth ? result :
     flattenPrototypeChain( Object.getPrototypeOf( target ), depth + 1, result.concat( target ), maxDepth );
 
+// Realm agnostic check for DOMException, works for AbortController errors even on environments without DOMExceptions
+export const isDomException = target => Object.prototype.toString.call( target ) === '[object DOMException]';
+
+const evaluateSpecialObjectsKeysList = target => {
+  // DOMException has a special serialization because it carries a bunch of legacy constant fields
+  // https://developer.mozilla.org/en-US/docs/Web/API/DOMException
+  if ( isDomException( target ) ) {
+    return [ 'name', 'message', 'code', 'cause', 'stack' ];
+  }
+  return null;
+};
+
 /**
  * Define the best "name" for an Error object
  * Rules: Assigned .name property > inherited .name if not "Error" > constructor.name
@@ -176,6 +188,8 @@ const serializeValue = ( target, options, state = { depth: 0, seen: new GlobalCo
     const prototypes = flattenPrototypeChain( target );
     const receiver = target;
 
+    const strictKeysList = evaluateSpecialObjectsKeysList( target );
+
     const props = prototypes.reduce( ( projection, proto ) => {
       if ( Object.keys( projection ).length > MAX_OBJECT_KEYS ) {
         return projection;
@@ -187,6 +201,10 @@ const serializeValue = ( target, options, state = { depth: 0, seen: new GlobalCo
           continue;
         }
 
+        if ( Array.isArray( strictKeysList ) && !strictKeysList.includes( key ) ) {
+          continue;
+        }
+
         const sanitizedKey = truncateString( key, MAX_OBJECT_KEY_LEN );
         if ( Object.hasOwn( projection, sanitizedKey ) ) { // do not overwrite similar keys
           continue;
@@ -212,7 +230,7 @@ const serializeValue = ( target, options, state = { depth: 0, seen: new GlobalCo
     if ( !options.ignoredKeys.includes( 'name' ) && target instanceof Error ) {
       const name = resolveErrorName( target );
       if ( name !== undefined ) {
-        props.name = name;
+        props.name = typeof name === 'string' ? truncateString( name ) : serializeValue( name, options, nextState );
       }
     }
 

package/src/helpers/error_serializer.spec.js

@@ -1,6 +1,7 @@
-import { describe, expect, it, vi } from 'vitest';
+import { afterEach, describe, expect, it, vi } from 'vitest';
 import {
   flattenPrototypeChain,
+  isDomException,
   resolveErrorName,
   serializeError,
   truncateArray,
@@ -43,6 +44,33 @@ describe( 'error serializer helpers', () => {
     } );
   } );
 
+  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 {}
@@ -194,6 +222,33 @@ describe( 'serializeError', () => {
     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' );
@@ -298,6 +353,17 @@ describe( 'serializeError', () => {
     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' );