Stop over-engineering. YAGNI!
Most JS codebases are light on polymorphism. I think I've used one UI framework that had any kind of inheritance at all. I've never (ever) had a bug caused by "forgetting to type new".
Use strict. Lint your code. Use a decent build toolchain. Stop over-engineering your code unless you have a damn good justification for it.
Using a constructor in the first place in a language that really doesn't need them is what's dogmatic.
That's not accurate; there are actual, technical reasons for avoiding new hence why some advise against using it.
I really don't want to get into this argument but that's not what dogma means. Dogma is something that comes from an authority as being undeniable but saying you can't or shouldn't use new isn't undeniable, it's deniable as you said yourself there are valid reasons for using new.
and now I hate myself. Thanks.
``` var yourClass = require('your-class');
var myInstance = yourClass(); ```
The only way I'd make the first mistake is if I was unfamiliar with `your-class`'s API, so nothing can save me there.
JSHint would catch the second one.
A file exposing a class SHOULD either wrap it: `module.exports = function () { return new YourClass(); }` or use `if (!(this instanceof YourClass)) return new YourClass()` guards in the constructor to stop users of a class having to worry about whether or not to use new.
At least this seems to be the convention many module publishers seem to adhere to.
If you want the benefits of `new` without exposing your interface, you should totally wrap it.
But if you're going to have boilerplate like that for code that not's performance critical (and most of it is not), why not just go for Object.create() and returning the instance yourself. Less action at a distance.