code: function fileReadAct( o )
  {
    let self = this;
    let con = new _.Consequence();
    let result = null;
  
    _.assert( arguments.length === 1, 'Expects single argument' );
    _.assertRoutineOptions( fileReadAct,o );
    _.assert( _.strIs( o.encoding ) );
  
    let encoder = fileReadAct.encoders[ o.encoding ];
  
    if( o.encoding )
    if( !encoder )
    return handleError( _.err( 'Encoding: ' + o.encoding + ' is not supported!' ) )
  
    /* exec */
  
    handleBegin();
  
    debugger; _.assert( 0, 'not implemented' );
  
    return handleEnd( result );
  
    /* begin */
  
    function handleBegin()
    {
  
      if( encoder && encoder.onBegin )
      _.sure( encoder.onBegin.call( self, { operation : o, encoder : encoder }) === undefined );
  
    }
  
    /* end */
  
    function handleEnd( data )
    {
  
      let context = { data : data, operation : o, encoder : encoder };
      if( encoder && encoder.onEnd )
      _.sure( encoder.onEnd.call( self,context ) === undefined );
  
      if( o.sync )
      {
        return context.data;
      }
      else
      {
        return con.take( context.data );
      }
  
    }
  
    /* error */
  
    function handleError( err )
    {
  
      debugger;
  
      if( encoder && encoder.onError )
      try
      {
        err = _._err
        ({
          args : [ stack,'\nfileReadAct( ',o.filePath,' )\n',err ],
          usingSourceCode : 0,
          level : 0,
        });
        err = encoder.onError.call( self,{ error : err, operation : o, encoder : encoder })
      }
      catch( err2 )
      {
        console.error( err2 );
        console.error( err.toString() + '\n' + err.stack );
      }
  
      if( o.sync )
      {
        throw err;
      }
      else
      {
        return con.error( err );
      }
  
    }
  
  }
docs: -- read --