All Errors

This error occurs when Node.js fails to complete a TLS handshake during an HTTPS or secure WebSocket connection. The client and server cannot agree on compatible encryption protocols, cipher suites, or certificate parameters, causing the secure connection to be rejected.

This error occurs when attempting to chain .then() on a value that is undefined instead of a Promise. It typically happens when a function fails to return a Promise, breaking the promise chain.

This error occurs when both sides of a Node.js duplex stream (readable and writable) fail or close prematurely before completing data transfer. It commonly happens due to improper error handling, missing event listeners, or abrupt connection terminations in network streams, transform streams, or bidirectional pipes.

The ENETUNREACH error occurs when Node.js cannot establish a network connection because the destination network is unreachable. This typically indicates routing problems, network interface issues, or firewall restrictions preventing your application from reaching the target host.

The EHOSTUNREACH error occurs when Node.js attempts to establish a TCP connection but cannot find any network route to reach the target host. This typically indicates network configuration issues, firewall blocks, or an unreachable server.

This error occurs when the operating system runs out of buffer space for network operations, typically during heavy socket operations or large data transfers. It indicates system-level resource exhaustion rather than a code-level bug.

This error occurs when you try to return an array of JSX elements from a React component without wrapping them in a Fragment or proper array syntax. React components can return arrays of elements, but they must be properly formatted with key props and array literal syntax.

This error occurs when trying to access the "length" property of an undefined value, typically on arrays or strings. In React, this commonly happens when component state, props, or API response data are undefined or not properly initialized, leading to crashes when accessing array methods or string properties.

The ENOENT (Error NO ENTry) error occurs when Node.js attempts to access a file or directory that does not exist at the specified path. This is one of the most common filesystem errors and typically results from incorrect file paths, relative path confusion, or missing files. Understanding how Node.js resolves paths is essential to fixing this error permanently.

This error occurs when Node.js attempts a file system operation that the operating system denies due to insufficient permissions. It commonly happens during chmod, rename, unlink, or write operations, particularly on Windows with antivirus software or on Unix-like systems with incorrect file ownership.

This error occurs when attempting to remove a directory that contains files or subdirectories using fs.rmdir() or fs.rmdirSync(). Node.js refuses to delete non-empty directories unless the recursive option is enabled.

This error occurs when ReactDOM.render() or createRoot() tries to mount to a DOM element that does not exist or is null. Common causes include targeting the wrong element ID, loading React before the DOM is ready, or missing the target div in your HTML. Fix it by ensuring the target element exists and scripts load after the DOM.

This error occurs when Node.js file system operations expect a directory path but receive a file path instead. It commonly appears with fs.readdir(), fs.scandir(), or file watching utilities.

The ESRCH error occurs when attempting to send a signal to a process that no longer exists. This typically happens with process.kill() or child process operations when the target process has already exited.

This error occurs when Node.js child_process.exec() tries to execute a command that cannot be found by the shell (/bin/sh). The shell either cannot locate the executable in PATH or the command does not exist on the system.

ETIMEDOUT occurs when a network operation in Node.js does not complete within the specified or default time limit. This typically happens during HTTP requests, database connections, or socket operations when the remote server fails to respond in time.

This warning appears when using the worker_threads module in Node.js versions prior to v12, where the feature was still experimental. Worker threads became stable in Node.js v12 LTS, so upgrading to v12+ is the primary solution.

This error occurs when trying to use the CommonJS global __filename in an ES module. ES modules use a different approach to access file paths and do not provide __filename by default.

This error occurs when a server acting as a gateway or proxy does not receive a timely response from an upstream server. It commonly happens when your Node.js application makes requests to external APIs, databases, or microservices that take too long to respond, exceeding the configured timeout limits.

This error occurs when child_process.execFile() attempts to execute a script file that lacks executable permissions. The Node.js process cannot spawn the file as a child process because the operating system denies execution.