All Errors

This error occurs when TypeScript's conditional types generate union branches that exceed the compiler's complexity limits. This typically happens with recursive conditional types or deeply nested generic constraints. Refactoring to break down complex type logic into simpler pieces usually resolves the issue.

This error occurs when Node.js crypto functions receive a private key in an incompatible or malformed format. The crypto module expects keys in specific encodings (PEM, DER, or JWK) with proper structure and headers.

This error occurs when a callback function passed to process.nextTick() throws an uncaught exception. Since nextTick callbacks execute before the event loop continues, unhandled errors in these callbacks will crash the Node.js process.

This error occurs when a Promise remains in a pending state indefinitely because neither resolve() nor reject() is ever called. The code after await never executes, causing operations to hang or the application to appear frozen.

Promise.all() rejects immediately when any single promise in the array rejects, causing an unhandled promise rejection if not properly caught. The entire operation fails even if other promises would have succeeded.

This warning occurs when promises remain unresolved indefinitely, preventing JavaScript's garbage collector from freeing memory. Long-lived or infinite promise chains accumulate in memory, eventually leading to performance degradation or out-of-memory crashes.

This error occurs when your Node.js application or npm tries to connect through a proxy server that requires authentication credentials. The request is rejected because no valid username and password were provided to the proxy.

This error occurs when code attempts to use a non-function value as a function, or when a function is expected to return a promise but returns a non-thenable value instead. It commonly happens in promise chains, async/await operations, or when working with promise constructors.

Node.js throws this error when require() or import attempts to load a module from a directory path that does not exist in the filesystem. This commonly happens due to incorrect paths, missing installations, or misconfigured module resolution.

A segmentation fault occurs when Node.js or a native addon attempts to access memory it is not permitted to access, causing the process to crash with a "Segmentation fault (core dumped)" message. This typically indicates a bug in native C/C++ modules rather than JavaScript code.

The spawn EACCES error occurs when Node.js attempts to spawn a child process but lacks execute permissions on the target executable. This commonly happens with binary files in node_modules or custom scripts that are missing the executable bit.

Your setImmediate() callback threw an unhandled exception or failed during execution. This error occurs because exceptions in setImmediate callbacks cannot be caught with try-catch and propagate unchecked through the Node.js event loop, crashing your process.

This error occurs when Node.js cannot verify the SSL/TLS certificate of a server you are trying to connect to. It typically happens with self-signed certificates, expired certificates, or missing intermediate certificates. The fix depends on whether you are in a development environment or production.

Node.js StringDecoder throws an error when you pass an unsupported or misspelled encoding. This happens when working with streams or buffers with invalid encoding specifications.

This error occurs when Node.js receives a malformed or unrecognized timezone string from the TZ environment variable. The TZ variable expects valid IANA timezone identifiers (like "America/New_York" or "Europe/London") or POSIX timezone strings, but receives an invalid or misspelled value instead. This causes date and time operations to fail or behave unpredictably.

A TLS handshake timeout occurs when the client and server fail to complete the SSL/TLS negotiation within the timeout period (default 120 seconds). This typically indicates network delays, server resource constraints, or infrastructure issues.

This error occurs when the hostname sent during TLS handshake (Server Name Indication) does not match the hostname on the SSL/TLS certificate. The server receives a different SNI name than what the certificate is valid for, causing verification to fail.

This error occurs when attempting to call cluster.fork() from a worker process instead of the primary (master) process. The cluster module enforces a strict master-worker hierarchy where only the primary process can spawn new workers.

This error occurs when Node.js receives an HTTP response with malformed chunked transfer encoding. The HTTP parser cannot properly decode the response body because the chunk format violates HTTP/1.1 specifications.

This error occurs when an exception is thrown inside a deferred callback (setTimeout, setImmediate, or process.nextTick) without proper error handling, potentially crashing the Node.js process.