@output.ai/core 0.2.0 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@output.ai/core",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "The core module of the output framework",
   "type": "module",
   "exports": {

package/src/index.d.ts

@@ -2,6 +2,18 @@ import type { z } from 'zod';
 import type { ActivityOptions } from '@temporalio/workflow';
 import type { SerializedFetchResponse } from './utils/index.d.ts';
 
+/**
+ * Similar to `Partial<T>` but applies to nested properties recursively, creating a deep optional variant of `T`:
+ * - Objects: All properties become optional, recursively.
+ * - Functions: Preserved as‑is (only the property itself becomes optional).
+ * - Primitives: Returned unchanged.
+ * Useful for config overrides with strong IntelliSense on nested fields and methods.
+ */
+type DeepPartial<T> =
+  T extends ( ...args: any[] ) => unknown ? T : // eslint-disable-line @typescript-eslint/no-explicit-any
+    T extends object ? { [K in keyof T]?: DeepPartial<T[K]> } :
+      T;
+
 /**
  * Expose z from Zod as a convenience.
  */
@@ -211,7 +223,7 @@ export declare function step<
  *
  * Allows overriding Temporal Activity options for this workflow.
  */
-export type WorkflowInvocationConfiguration = {
+export type WorkflowInvocationConfiguration<Context extends WorkflowContext = WorkflowContext> = {
 
   /**
    * Native Temporal Activity options
@@ -223,6 +235,11 @@ export type WorkflowInvocationConfiguration = {
    * Detached workflows called without explicitly awaiting the result are "fire-and-forget" and may outlive the parent.
    */
   detached?: boolean
+
+  /**
+   * Allow to overwrite properties of the "context" of workflows when called in tests environments.
+   */
+  context?: DeepPartial<Context>
 };
 
 /**
@@ -265,7 +282,8 @@ export type WorkflowContext<
       ( input: z.infer<InputSchema> ) => ( OutputSchema extends AnyZodSchema ? z.infer<OutputSchema> : void ) :
       () => ( OutputSchema extends AnyZodSchema ? z.infer<OutputSchema> : void ),
 
-    /** Indicates whether the Temporal runtime suggests continuing this workflow as new.
+    /**
+     * Indicates whether the Temporal runtime suggests continuing this workflow as new.
      *
      * Use this to decide whether to `continueAsNew` before long waits or at loop boundaries.
      * Prefer returning the `continueAsNew(...)` call immediately when this becomes `true`.
@@ -275,6 +293,18 @@ export type WorkflowContext<
      * @returns True if a continue-as-new is suggested for the current run; otherwise false.
      */
     isContinueAsNewSuggested: () => boolean
+  },
+
+  /**
+   * Information about the workflow execution
+   */
+  info: {
+    /**
+     * Internal Temporal workflow id.
+     *
+     * @see {@link https://docs.temporal.io/workflow-execution/workflowid-runid#workflow-id}
+     */
+    workflowId: string
   }
 };
 
@@ -310,8 +340,10 @@ export type WorkflowFunction<
  */
 export type WorkflowFunctionWrapper<WorkflowFunction> =
   [Parameters<WorkflowFunction>[0]] extends [undefined | null] ?
-    ( input?: undefined | null, config?: WorkflowInvocationConfiguration ) => ReturnType<WorkflowFunction> :
-    ( input: Parameters<WorkflowFunction>[0], config?: WorkflowInvocationConfiguration ) => ReturnType<WorkflowFunction>;
+    ( input?: undefined | null, config?: WorkflowInvocationConfiguration<Parameters<WorkflowFunction>[1]> ) =>
+    ReturnType<WorkflowFunction> :
+    ( input: Parameters<WorkflowFunction>[0], config?: WorkflowInvocationConfiguration<Parameters<WorkflowFunction>[1]> ) =>
+    ReturnType<WorkflowFunction>;
 
 /**
  * Creates a workflow.
@@ -477,6 +509,11 @@ export class EvaluationResult {
    * @returns The evaluation result reasoning
    */
   get reasoning(): string;
+
+  /**
+   * @returns A zod schema representing this class
+   */
+  get schema(): string;
 }
 
 /**

package/src/interface/evaluator.js

@@ -34,11 +34,17 @@ export class EvaluationResult {
    */
   reasoning = undefined;
 
-  static #schema = z.object( {
-    value: z.any(),
-    confidence: z.number(),
-    reasoning: z.string().optional()
-  } );
+  static get valueSchema() {
+    return z.any();
+  };
+
+  static get schema() {
+    return z.object( {
+      value: this.valueSchema,
+      confidence: z.number(),
+      reasoning: z.string().optional()
+    } );
+  };
 
   /**
    * @constructor
@@ -48,7 +54,7 @@ export class EvaluationResult {
    * @param {string} [args.reasoning] - The reasoning behind the result
    */
   constructor( args ) {
-    const result = EvaluationResult.#schema.safeParse( args );
+    const result = this.constructor.schema.safeParse( args );
     if ( result.error ) {
       throw new EvaluationResultValidationError( z.prettifyError( result.error ) );
     }
@@ -64,7 +70,9 @@ export class EvaluationResult {
  * @property {string} value - The evaluation result value
  */
 export class EvaluationStringResult extends EvaluationResult {
-  static #valueSchema = z.string();
+  static get valueSchema() {
+    return z.string();
+  };
 
   /**
    * @constructor
@@ -74,10 +82,6 @@ export class EvaluationStringResult extends EvaluationResult {
    * @param {string} [args.reasoning] - The reasoning behind the result
    */
   constructor( args ) {
-    const result = EvaluationStringResult.#valueSchema.safeParse( args.value );
-    if ( result.error ) {
-      throw new EvaluationResultValidationError( z.prettifyError( result.error ) );
-    }
     super( args );
   }
 };
@@ -88,7 +92,9 @@ export class EvaluationStringResult extends EvaluationResult {
  * @property {boolean} value - The evaluation result value
  */
 export class EvaluationBooleanResult extends EvaluationResult {
-  static #valueSchema = z.boolean();
+  static get valueSchema() {
+    return z.boolean();
+  };
 
   /**
    * @constructor
@@ -98,10 +104,6 @@ export class EvaluationBooleanResult extends EvaluationResult {
    * @param {string} [args.reasoning] - The reasoning behind the result
    */
   constructor( args ) {
-    const result = EvaluationBooleanResult.#valueSchema.safeParse( args.value );
-    if ( result.error ) {
-      throw new EvaluationResultValidationError( z.prettifyError( result.error ) );
-    }
     super( args );
   }
 };
@@ -112,7 +114,9 @@ export class EvaluationBooleanResult extends EvaluationResult {
  * @property {number} value - The evaluation result value
  */
 export class EvaluationNumberResult extends EvaluationResult {
-  static #valueSchema = z.number();
+  static get valueSchema() {
+    return z.number();
+  };
 
   /**
    * @constructor
@@ -122,10 +126,6 @@ export class EvaluationNumberResult extends EvaluationResult {
    * @param {string} [args.reasoning] - The reasoning behind the result
    */
   constructor( args ) {
-    const result = EvaluationNumberResult.#valueSchema.safeParse( args.value );
-    if ( result.error ) {
-      throw new EvaluationResultValidationError( z.prettifyError( result.error ) );
-    }
     super( args );
   }
 };
@@ -138,7 +138,7 @@ export function evaluator( { name, description, inputSchema, fn, options } ) {
 
     const output = await fn( input );
 
-    if ( !output instanceof EvaluationResult ) {
+    if ( !( output instanceof EvaluationResult ) ) {
       throw new ValidationError( 'Evaluators must return an EvaluationResult' );
     }
 

package/src/interface/evaluator.spec.js

@@ -0,0 +1,103 @@
+import { describe, it, expect } from 'vitest';
+import {
+  EvaluationResult,
+  EvaluationStringResult,
+  EvaluationNumberResult,
+  EvaluationBooleanResult
+} from './evaluator.js';
+import { ValidationError } from '#errors';
+
+describe( 'interface/evaluator - EvaluationResult classes', () => {
+  describe( 'class inheritance', () => {
+    it( 'subclasses extend EvaluationResult', () => {
+      const s = new EvaluationStringResult( { value: 'ok', confidence: 0.8 } );
+      const n = new EvaluationNumberResult( { value: 42, confidence: 1 } );
+      const b = new EvaluationBooleanResult( { value: true, confidence: 0.5 } );
+
+      expect( s ).toBeInstanceOf( EvaluationResult );
+      expect( n ).toBeInstanceOf( EvaluationResult );
+      expect( b ).toBeInstanceOf( EvaluationResult );
+    } );
+  } );
+
+  describe( 'constructor payload validation', () => {
+    it( 'base class validates presence and types of common fields', () => {
+      // valid
+      const base = new EvaluationResult( { value: { any: 'thing' }, confidence: 0.1 } );
+      expect( base.value ).toEqual( { any: 'thing' } );
+      expect( base.confidence ).toBe( 0.1 );
+      expect( base.reasoning ).toBeUndefined();
+
+      // invalid: missing confidence
+      expect( () => new EvaluationResult( { value: 1 } ) ).toThrow( ValidationError );
+
+      // invalid: confidence wrong type
+      expect( () => new EvaluationResult( { value: 'x', confidence: 'nope' } ) ).toThrow( ValidationError );
+
+      // invalid: reasoning wrong type
+      expect( () => new EvaluationResult( { value: 'x', confidence: 1, reasoning: 123 } ) ).toThrow( ValidationError );
+    } );
+
+    it( 'string subclass enforces string value', () => {
+      // valid
+      const r = new EvaluationStringResult( { value: 'hello', confidence: 0.9 } );
+      expect( r.value ).toBe( 'hello' );
+
+      // invalid
+      expect( () => new EvaluationStringResult( { value: 123, confidence: 0.2 } ) ).toThrow( ValidationError );
+    } );
+
+    it( 'number subclass enforces number value', () => {
+      // valid
+      const r = new EvaluationNumberResult( { value: 123, confidence: 0.2 } );
+      expect( r.value ).toBe( 123 );
+
+      // invalid
+      expect( () => new EvaluationNumberResult( { value: 'nope', confidence: 0.2 } ) ).toThrow( ValidationError );
+    } );
+
+    it( 'boolean subclass enforces boolean value', () => {
+      // valid
+      const r = new EvaluationBooleanResult( { value: true, confidence: 1 } );
+      expect( r.value ).toBe( true );
+
+      // invalid
+      expect( () => new EvaluationBooleanResult( { value: 'nope', confidence: 0.2 } ) ).toThrow( ValidationError );
+    } );
+  } );
+
+  describe( 'static schema getter', () => {
+    it( 'base schema accepts any value and optional reasoning', () => {
+      const ok = EvaluationResult.schema.safeParse( { value: 'x', confidence: 0.5, reasoning: 'why' } );
+      expect( ok.success ).toBe( true );
+
+      const ok2 = EvaluationResult.schema.safeParse( { value: 123, confidence: 0.5 } );
+      expect( ok2.success ).toBe( true );
+    } );
+
+    it( 'string schema requires value to be string', () => {
+      const ok = EvaluationStringResult.schema.safeParse( { value: 'x', confidence: 1 } );
+      expect( ok.success ).toBe( true );
+
+      const bad = EvaluationStringResult.schema.safeParse( { value: 123, confidence: 1 } );
+      expect( bad.success ).toBe( false );
+    } );
+
+    it( 'number schema requires value to be number', () => {
+      const ok = EvaluationNumberResult.schema.safeParse( { value: 10, confidence: 1 } );
+      expect( ok.success ).toBe( true );
+
+      const bad = EvaluationNumberResult.schema.safeParse( { value: '10', confidence: 1 } );
+      expect( bad.success ).toBe( false );
+    } );
+
+    it( 'boolean schema requires value to be boolean', () => {
+      const ok = EvaluationBooleanResult.schema.safeParse( { value: false, confidence: 1 } );
+      expect( ok.success ).toBe( true );
+
+      const bad = EvaluationBooleanResult.schema.safeParse( { value: 'false', confidence: 1 } );
+      expect( bad.success ).toBe( false );
+    } );
+  } );
+} );
+

package/src/interface/workflow.js

@@ -3,9 +3,41 @@ import { proxyActivities, inWorkflowContext, executeChild, workflowInfo, uuid4,
 import { validateWorkflow } from './validations/static.js';
 import { validateWithSchema } from './validations/runtime.js';
 import { SHARED_STEP_PREFIX, ACTIVITY_GET_TRACE_DESTINATIONS } from '#consts';
-import { mergeActivityOptions, resolveInvocationDir, setMetadata } from '#utils';
+import { deepMerge, mergeActivityOptions, resolveInvocationDir, setMetadata } from '#utils';
 import { FatalError, ValidationError } from '#errors';
 
+/**
+ * Context instance builder
+ */
+class Context {
+
+  /**
+   * Builds a new context instance
+   * @param {object} options - Arguments to build a new context instance
+   * @param {string} workflowId
+   * @param {function} continueAsNew
+   * @param {function} isContinueAsNewSuggested
+   * @returns {object} context
+   */
+  static build( { workflowId, continueAsNew, isContinueAsNewSuggested } ) {
+    return {
+      /**
+       * Control namespace: This object adds functions to interact with Temporal flow mechanisms
+       */
+      control: {
+        continueAsNew,
+        isContinueAsNewSuggested
+      },
+      /**
+       * Info namespace: abstracts workflowInfo()
+       */
+      info: {
+        workflowId
+      }
+    };
+  }
+};
+
 const defaultActivityOptions = {
   startToCloseTimeout: '20m',
   retry: {
@@ -24,26 +56,26 @@ export function workflow( { name, description, inputSchema, outputSchema, fn, op
   const activityOptions = mergeActivityOptions( defaultActivityOptions, options );
   const steps = proxyActivities( activityOptions );
 
-  const wrapper = async input => {
+  /**
+   * Wraps the `fn` function of the workflow
+   *
+   * @param {unknown} input - The input, must match the inputSchema
+   * @param {object} extra - Workflow configurations (received directly only in unit tests)
+   * @returns {unknown} The result, will match the outputSchema
+   */
+  const wrapper = async ( input, extra = {} ) => {
     // this returns a plain function, for example, in unit tests
     if ( !inWorkflowContext() ) {
       validateWithSchema( inputSchema, input, `Workflow ${name} input` );
-      const output = await fn( input );
+      const context = Context.build( { workflowId: 'test-workflow', continueAsNew: async () => {}, isContinueAsNewSuggested: () => false } );
+      const output = await fn( input, deepMerge( context, extra.context ?? {} ) );
       validateWithSchema( outputSchema, output, `Workflow ${name} output` );
       return output;
     }
 
     const { workflowId, memo, startTime } = workflowInfo();
 
-    /* Context Object definition
-       - Control namespace: This object adds functions to interact with Temporal flow mechanisms
-    */
-    const context = {
-      control: {
-        isContinueAsNewSuggested: () => workflowInfo().continueAsNewSuggested,
-        continueAsNew
-      }
-    };
+    const context = Context.build( { workflowId, continueAsNew, isContinueAsNewSuggested: () => workflowInfo().continueAsNewSuggested } );
 
     // Root workflows will not have the execution context yet, since it is set here.
     const isRoot = !memo.executionContext;

package/src/utils/index.d.ts

@@ -63,18 +63,48 @@ export type SerializedFetchResponse = {
 };
 
 /**
- * Consumes and HTTP Response and serialize it to a plain object
+ * Consumes an HTTP `Response` and serializes it to a plain object.
+ *
+ * @param response - The response to serialize.
+ * @returns SerializedFetchResponse
  */
 export function serializeFetchResponse( response: Response ): SerializedFetchResponse;
 
 export type SerializedBodyAndContentType = {
-  /** The body parsed to string if possible or kept as the types allowed in fetch's POST body */
+  /** The body as a string when possible; otherwise the original value */
   body: string | unknown,
-  /** The inferred content-type */
+  /** The inferred `Content-Type` header value, if any */
   contentType: string | undefined
 };
 
 /**
- * Based on the type of a payload, serialized it to be send as the body of a fetch POST request and also infer its Content Type.
+ * Serializes a payload for use as a fetch POST body and infers its `Content-Type`.
+ *
+ * @param body - The payload to serialize.
+ * @returns The serialized body and inferred `Content-Type`.
  */
 export function serializeBodyAndInferContentType( body: unknown ): SerializedBodyAndContentType;
+
+/**
+ * Returns true if the value is a plain object:
+ * - `{}`
+ * - `new Object()`
+ * - `Object.create(null)`
+ *
+ * @param object - The value to check.
+ * @returns Whether the value is a plain object.
+ */
+export function isPlainObject( object: unknown ): boolean;
+
+/**
+ * Creates a new object by merging object `b` onto object `a`, biased toward `b`:
+ * - Fields in `b` overwrite fields in `a`.
+ * - Fields in `b` that don't exist in `a` are created.
+ * - Fields in `a` that don't exist in `b` are left unchanged.
+ *
+ * @param a - The base object.
+ * @param b - The overriding object.
+ * @throws {Error} If either `a` or `b` is not a plain object.
+ * @returns A new merged object.
+ */
+export function deepMerge( a: object, b: object ): object;

package/src/utils/utils.js

@@ -7,6 +7,18 @@ import { METADATA_ACCESS_SYMBOL } from '#consts';
  */
 export const clone = v => JSON.parse( JSON.stringify( v ) );
 
+/**
+ * Detect a JS plain object.
+ *
+ * @param {unknown} v
+ * @returns {boolean}
+ */
+export const isPlainObject = v =>
+  typeof v === 'object' &&
+    !Array.isArray( v ) &&
+    v !== null &&
+    [ Object.prototype, null ].includes( Object.getPrototypeOf( v ) );
+
 /**
  * Throw given error
  * @param {Error} e
@@ -149,3 +161,26 @@ export const serializeBodyAndInferContentType = payload => {
 
   return { body: String( payload ), contentType: 'text/plain; charset=UTF-8' };
 };
+
+/**
+ * Creates a new object merging object "b" onto object "a" biased to "b":
+ * - Object "b" will overwrite fields on object "a";
+ * - Object "b" fields that don't exist on object "a" will be created;
+ * - Object "a" fields that don't exist on object "b" will not be touched;
+ *
+ *
+ * @param {object} a - The base object
+ * @param {object} b - The target object
+ * @returns {object} A new object
+ */
+export const deepMerge = ( a, b ) => {
+  if ( !isPlainObject( a ) ) {
+    throw new Error( 'Parameter "a" is not an object.' );
+  }
+  if ( !isPlainObject( b ) ) {
+    throw new Error( 'Parameter "b" is not an object.' );
+  }
+  return Object.entries( b ).reduce( ( obj, [ k, v ] ) =>
+    Object.assign( obj, { [k]: isPlainObject( v ) && isPlainObject( a[k] ) ? deepMerge( a[k], v ) : v } )
+  , clone( a ) );
+};

package/src/utils/utils.spec.js

@@ -1,7 +1,6 @@
 import { describe, it, expect } from 'vitest';
 import { Readable } from 'node:stream';
-import { clone, mergeActivityOptions, serializeBodyAndInferContentType, serializeFetchResponse } from './utils.js';
-// Response is available globally in Node 18+ (undici)
+import { clone, mergeActivityOptions, serializeBodyAndInferContentType, serializeFetchResponse, deepMerge, isPlainObject } from './utils.js';
 
 describe( 'clone', () => {
   it( 'produces a deep copy without shared references', () => {
@@ -260,3 +259,155 @@ describe( 'mergeActivityOptions', () => {
   } );
 } );
 
+describe( 'deepMerge', () => {
+  it( 'Overwrites properties in object "a"', () => {
+    const a = {
+      a: 1,
+      b: {
+        c: 2
+      }
+    };
+    const b = {
+      a: false,
+      b: {
+        c: true
+      }
+    };
+    expect( deepMerge( a, b ) ).toEqual( {
+      a: false,
+      b: {
+        c: true
+      }
+    } );
+  } );
+
+  it( 'Adds properties existing in "b" but absent in "a"', () => {
+    const a = {
+      a: 1
+    };
+    const b = {
+      a: false,
+      b: true
+    };
+    expect( deepMerge( a, b ) ).toEqual( {
+      a: false,
+      b: true
+    } );
+  } );
+
+  it( 'Keep extra properties in "a"', () => {
+    const a = {
+      a: 1
+    };
+    const b = {
+      b: true
+    };
+    expect( deepMerge( a, b ) ).toEqual( {
+      a: 1,
+      b: true
+    } );
+  } );
+
+  it( 'Throw error on non iterable object types', () => {
+    expect( () => deepMerge( Function, Function ) ).toThrow( Error );
+    expect( () => deepMerge( () => {}, () => {} ) ).toThrow( Error );
+    expect( () => deepMerge( 'a', 'a' ) ).toThrow( Error );
+    expect( () => deepMerge( true, true ) ).toThrow( Error );
+    expect( () => deepMerge( /a/, /a/ ) ).toThrow( Error );
+    expect( () => deepMerge( [], [] ) ).toThrow( Error );
+    expect( () => deepMerge( class Foo {}, class Foo {} ) ).toThrow( Error );
+    expect( () => deepMerge( Number.constructor, Number.constructor ) ).toThrow( Error );
+    expect( () => deepMerge( Number.constructor.prototype, Number.constructor.prototype ) ).toThrow( Error );
+  } );
+} );
+
+describe( 'isPlainObject', () => {
+  it( 'Detects plain objects', () => {
+    expect( isPlainObject( {} ) ).toBe( true );
+    expect( isPlainObject( { a: 1 } ) ).toBe( true );
+    expect( isPlainObject( new Object() ) ).toBe( true );
+    expect( isPlainObject( new Object( { foo: 'bar' } ) ) ).toBe( true );
+    expect( isPlainObject( Object.create( {}.constructor.prototype ) ) ).toBe( true );
+    expect( isPlainObject( Object.create( Object.prototype ) ) ).toBe( true );
+  } );
+
+  it( 'Detects plain objects with different prototypes than Object.prototype', () => {
+    // Object with null prototype
+    expect( isPlainObject( Object.create( null ) ) ).toBe( true );
+  } );
+
+  it( 'Detects non plain objects that had their __proto__ mutated to Object.prototype or null', () => {
+    class Foo {}
+    const x = new Foo();
+    x.__proto__ = Object.prototype;
+    expect( isPlainObject( x ) ).toBe( true );
+
+    const y = new Foo();
+    y.__proto__ = null;
+    expect( isPlainObject( y ) ).toBe( true );
+  } );
+
+  it( 'Returns false for object which the prototype is not Object.prototype or null', () => {
+    // Object which the prototype is a plain {}
+    expect( isPlainObject( Object.create( {} ) ) ).toBe( false );
+    // Object which prototype is a another object with null prototype
+    expect( isPlainObject( Object.create( Object.create( null ) ) ) ).toBe( false );
+  } );
+
+  it( 'Returns false for functions', () => {
+    expect( isPlainObject( Function ) ).toBe( false );
+    expect( isPlainObject( () => {} ) ).toBe( false );
+    expect( isPlainObject( class Foo {} ) ).toBe( false );
+    expect( isPlainObject( Number.constructor ) ).toBe( false );
+    expect( isPlainObject( Number.constructor.prototype ) ).toBe( false );
+  } );
+
+  it( 'Returns false for arrays', () => {
+    expect( isPlainObject( [ 1, 2, 3 ] ) ).toBe( false );
+    expect( isPlainObject( [] ) ).toBe( false );
+    expect( isPlainObject( Array( 3 ) ) ).toBe( false );
+  } );
+
+  it( 'Returns false for primitives', () => {
+    expect( isPlainObject( false ) ).toBe( false );
+    expect( isPlainObject( true ) ).toBe( false );
+    expect( isPlainObject( 1 ) ).toBe( false );
+    expect( isPlainObject( 0 ) ).toBe( false );
+    expect( isPlainObject( '' ) ).toBe( false );
+    expect( isPlainObject( 'foo' ) ).toBe( false );
+    expect( isPlainObject( Symbol( 'foo' ) ) ).toBe( false );
+    expect( isPlainObject( Symbol.for( 'foo' ) ) ).toBe( false );
+  } );
+
+  it( 'Returns true for built in objects', () => {
+    expect( isPlainObject( Math ) ).toBe( true );
+    expect( isPlainObject( JSON ) ).toBe( true );
+  } );
+
+  it( 'Returns false for built in types', () => {
+    expect( isPlainObject( String ) ).toBe( false );
+    expect( isPlainObject( Number ) ).toBe( false );
+    expect( isPlainObject( Date ) ).toBe( false );
+  } );
+
+  it( 'Returns false for other instance where prototype is not object or null', () => {
+    expect( isPlainObject( /foo/ ) ).toBe( false );
+    expect( isPlainObject( new RegExp( 'foo' ) ) ).toBe( false );
+    expect( isPlainObject( new Date() ) ).toBe( false );
+    class Foo {}
+    expect( isPlainObject( new Foo() ) ).toBe( false );
+    expect( isPlainObject( Object.create( ( class Foo {} ).prototype ) ) ).toBe( false );
+  } );
+
+  it( 'Returns false if tries to change the prototype to simulate an object', () => {
+    function Bar() {}
+    Bar.prototype = Object.create( null );
+    expect( isPlainObject( new Bar() ) ).toBe( false );
+  } );
+
+  it( 'Returns false if object proto was mutated to anything else than object or null', () => {
+    const zum = {};
+    zum.__proto__ = Number.prototype;
+    expect( isPlainObject( zum ) ).toBe( false );
+  } );
+} );