Is it possible to modify Error's constructor so that it includes the context in which the error was thrown?

Call me insane, but I want all JavaScript errors to expose the context of this when they were thrown. Hard to explain in English, easier to explain what I want in code:

var Person = function() {
    this.name = 'Chuck';
}

Person.prototype.speak = function() {
    throw new Error('muted!');
    console.log('My name is', this.name);
}

var person = new Person();

try {
    person.speak(); 
}
catch(error) {
    console.log(error.context.name, 'could not speak.');
}

Is it possible for me to automatically populate the error.context property such that the code above will work? I'm open to any crazy tricks and using the next version of JavaScript or node.js.

Edit: I'd like to do this without using a custom error. This way I can catch any non-custom errors and still have access to context.

Simply attach properties to your error before throwing it (maybe wrap it with a nice function):

var obj = {
    foo : 'thingonabob',

    ouch : function () {
        var err = new Error();
        err.context = this;
        throw err;
    }
};

try {
    obj.ouch();
}
catch (e) {
    console.error('The darned %s is at it again!', e.context.foo)
}

A possible helper function for this:

function ContextifiedError (message, context) {
    var err = new Error(message);
    err.context = context;

    return err;
}

And then you throw ContextifiedError('something', this)

Edit: As @BenjaminGruenbaum points out, the stack trace is off by one when using the helper. If you care, you can write out a longer-but-somewhat-more-correct helper:

function ContextifiedError (message, context) {
    this.context = context;
    this.type = 'ContextifiedError';


    Error.call(this, message);
    if (Error.captureStackTrace) {
        Error.captureStackTrace(this, this.constructor);
    }
}
ContextifiedError.prototype = Error.prototype;
ContextifiedError.prototype.constructor = ContextifiedError;

The Error.call is for calling our "father constructor" on ourselves. Error.captureStackTrace, on modern browsers, makes sure we have a correct .stack property (see this article for an explanation). The rest is boilerplate.

And then you can throw new ContextifiedError('something', this).