I respectfully disagree here. Exiting may be OK when Karma is run independently or a child process, but in case it's require()'d by another node project internally a graceful exit may be preferred.

Actually, this kind of graceful error logic (log the error, let the caller decide) has been in the code so far.
[preprocessor.js snippet:](https://github.com/gvarsanyi/karma-coverage/blob/instrumenter-option/lib/preprocessor.js#L39-42)
```javascript
    instrumenter.instrument(content, jsPath, function(err, instrumentedCode) {
      if (err) {
        log.error('%s\n  at %s', err.message, file.originalPath);
      }
```

I am wondering if there is a sane way to return an error with the callback. The widely used (e.g. by node itself, many node projects etc) pattern is:
```coffeescript
asyncFn = (args..., callback) ->
  # ... will call the callback fn at some point
asyncFn 1, 2, 3, (err, results...) ->
  if err?
    # handle the error
```
but here the error handling piece seems to be missing (at the first glance anyway).

Also, if you use karma internally, there is a callback that is supposed to be called when karma is finished
```coffeescript
karma = require 'karma'
karma.server.start options, (exit_code) ->
  # exit_code is supposed to give me an idea about the state of errors I assume
  # I would also assume this is guaranteed to be called back
```
with calling process.exit(1); on error my bold assumptions would all go wrong :)

i agree that the ambiguity that comes with just error logging and ignoring a pattern may be bad, but force-terminating a process might be worse.

please let me know what you think