Here is a simple example of what I want :

```
var ConstBuilder = function() {
    var constructor = function() {} ;
    constructor.prototype = {} ;
    return constructor ;
} ;

ConstBuilder.prototype = {
    add : function(name, value) {
        this.prototype[name] = value ;
    }
} ;

var A = new ConstBuilder() ;
A.add('test', function() {
    console.log('test') ;
}) ;

var a = new A() ;
a.test() ;

```

This code will fail as `A` is not an instance of `ConstBuilder` (because `A` comes from a returned `var constructor = function() {}` and won't have the methods defined in its prototype (`add`).

But this would be useful to modify the super constructor's prototype to have things like :

```
ConstBuilder.prototype.remove = function(name) {
    delete this.prototype[name] ;
} ;

A.remove('test') ;

a.test ; // undefined

```

Is there a way to have a function as an instance of another ? So this function may implicitely "inherit" all the methods defined in its constructor's prototype.

Or if you have other suggestions, I aim to build modulable constructors - as instances with prototypes are.