Question

What is the connection between the outer var Message and the inner var Message?

The Call

new Message ( element ).display( server_response_text.slice( 6 ) );

Object

var Message = ( function () 
{
    var messages = 
    {
        name:         'Please enter a valid name',
        email:        'Please enter a valid email',
        email_s:      'Please enter a valid email.',
        pass:         'Please enter passoword, 6-40 characters',
        url:          'Please enter a valid url',
        title:        'Please enter a valid title',
        tweet:        'Please enter a valid tweet',
        empty:        'Please complete all fields',
        same:         'Please make emails equal',
        taken:        'Sorry, that email is taken',
        validate:     'Please contact <a class="d" href="mailto:[e-mail]">support</a> to reset your password',
    };
    var Message = function (element) 
    {
        this.element = element;
    };
    Message.prototype.display = function( type ) 
    {
        this.element.innerHTML = messages[ type ];
        new Effects().fade( this.element, 'down', 4000 );
    };
    return Message;
} () );

My entire library is using the module pattern like this

    var NS = ( function ( window, undefined ) 
    {
    /*
    all code here including Message
    */
    } )( window );

Answer 1

There is no relationship¹ to the variable names at all.

It is just the name used inside. It might as well be fuubar:

var fuubar = function (element) 
{
    this.element = element;
};
fuubar.prototype.display = function( type ) 
{
    this.element.innerHTML = messages[ type ];
    new Effects().fade( this.element, 'down', 4000 );
};
return fuubar; // the Object is returned, the Variable (Name) is not

It makes sense that the outer name is Message, because that is how it is “known” to others. ¹The inner name was likely chosen for consistency, but otherwise does not affect semantics.

Constructors are just function-objects [designed to be] invoked with the new operator. Variables can name objects. In this case note that it is the function-object that is returned. Thus the function-object is known by the name Message (e.g. “is assigned to Message”) outside. However, a variable is not an object.

Thus new X() evaluates the expression X, which must evaluate to a function-object, and then uses it as a constructor. (A constructor is just a normal function that expects to be used with new: it may perform initialization and establish a [[prototype]]). The name X is not important except insofar as it must evaluate to a function-object. Consider this equivalent form to show: new (X)(). The expression (X) is evaluated first.

So, let’s break down the code:

var Message = (function () {
   // This function is invoked immediately, due to the
   // parenthesis immediately after the FunctionExpression.
   // As noted above the name Message used inside is not important.
   // What *IS* important is that a Constructor, which is just
   // a function-object (which is just an object) is returned.
   // This returned object will be assigned to (the outer)
   // Message variable. That is, it is "named by Message"
   // after the assignment occurs.
})()

// At this point Message will evaluate to a function-object
// (a Constructor in particular).
Message instanceof Function // -> true

// And we can use it to create new messages:
var messageA = new Message("a")
var messageB = new Message("b")

Happy coding.