Errores

Las aplicaciones que se ejecutan en Node.js generalmente experimentan cuatro categorías de errores:

Errores estándar de JavaScript como <EvalError>, <SyntaxError>, <RangeError>, <ReferenceError>, <TypeError> y <URIError>.
Errores del sistema activados por las limitaciones del sistema operativo subyacente, como intentar abrir un archivo que no existe o intentar enviar datos a través de un socket cerrado.
Errores especificados por el usuario activados por el código de la aplicación.
Los AssertionError son una clase especial de error que se puede activar cuando Node.js detecta una violación lógica excepcional que nunca debería ocurrir. Estos suelen ser provocados por el módulo node:assert.

Todos los errores de JavaScript y del sistema generados por Node.js heredan, o son instancias de, la clase estándar de JavaScript <Error> y se garantiza que proporcionarán al menos las propiedades disponibles en esa clase.

Propagación e interceptación de errores

Node.js admite varios mecanismos para propagar y manejar los errores que ocurren mientras se ejecuta una aplicación. La forma en que se informan y manejan estos errores depende completamente del tipo de Error y del estilo de la API a la que se llama.

Todos los errores de JavaScript se manejan como excepciones que inmediatamente generan y arrojan un error utilizando el mecanismo estándar throw de JavaScript. Estos se manejan utilizando la construcción try…catch proporcionada por el lenguaje JavaScript.

// Lanza con un ReferenceError porque z no está definido.
try {
  const m = 1;
  const n = m + z;
} catch (err) {
  // Maneja el error aquí.
}

Cualquier uso del mecanismo throw de JavaScript generará una excepción que debe ser manejada o el proceso de Node.js saldrá inmediatamente.

Con pocas excepciones, las APIs Síncronas (cualquier método de bloqueo que no devuelva una <Promise> ni acepte una función callback, como fs.readFileSync), utilizarán throw para informar de los errores.

Los errores que ocurren dentro de las APIs Asíncronas pueden ser reportados de múltiples maneras:

Algunos métodos asíncronos devuelven una <Promise>, siempre debes tener en cuenta que podría ser rechazada. Consulta el flag --unhandled-rejections para saber cómo reaccionará el proceso a un rechazo de promesa no manejado.
La mayoría de los métodos asíncronos que aceptan una función callback aceptarán un objeto Error pasado como primer argumento a esa función. Si ese primer argumento no es null y es una instancia de Error, entonces ocurrió un error que debe ser manejado.
Cuando se llama a un método asíncrono en un objeto que es un EventEmitter, los errores pueden ser enrutados al evento 'error' de ese objeto.
Un puñado de métodos típicamente asíncronos en la API de Node.js todavía pueden usar el mecanismo throw para lanzar excepciones que deben ser manejadas usando try…catch. No hay una lista completa de tales métodos; por favor, consulta la documentación de cada método para determinar el mecanismo de manejo de errores apropiado requerido.

El uso del mecanismo de evento 'error' es más común para las APIs basadas en streams y basadas en emisores de eventos, que en sí mismas representan una serie de operaciones asíncronas a lo largo del tiempo (en contraposición a una sola operación que puede pasar o fallar).

Para todos los objetos EventEmitter, si no se proporciona un controlador de eventos 'error', el error será lanzado, causando que el proceso de Node.js reporte una excepción no capturada y se bloquee a menos que: se haya registrado un controlador para el evento 'uncaughtException', o se utilice el módulo obsoleto node:domain.

const EventEmitter = require('node:events');
const ee = new EventEmitter();

setImmediate(() => {
  // Esto bloqueará el proceso porque no se ha añadido ningún controlador
  // de eventos 'error'.
  ee.emit('error', new Error('Esto bloqueará'));
});

Los errores generados de esta manera no pueden ser interceptados usando try…catch ya que se lanzan después de que el código de llamada ya haya salido.

Los desarrolladores deben consultar la documentación de cada método para determinar exactamente cómo se propagan los errores generados por esos métodos.

Clase: `Error`

Un objeto genérico de JavaScript <Error> que no denota ninguna circunstancia específica de por qué ocurrió el error. Los objetos Error capturan un "rastreo de pila" que detalla el punto en el código en el que se instanció el Error, y pueden proporcionar una descripción textual del error.

Todos los errores generados por Node.js, incluidos todos los errores del sistema y de JavaScript, serán instancias de la clase Error o heredarán de ella.

`new Error(message[, options])`

message <string>
options <Object>
- cause <any> El error que causó el error recién creado.

Crea un nuevo objeto Error y establece la propiedad error.message al mensaje de texto proporcionado. Si se pasa un objeto como message, el mensaje de texto se genera llamando a String(message). Si se proporciona la opción cause, se asigna a la propiedad error.cause. La propiedad error.stack representará el punto en el código en el que se llamó a new Error(). Los rastreos de pila dependen de la API de rastreo de pila de V8. Los rastreos de pila se extienden solo hasta (a) el comienzo de la ejecución síncrona del código o (b) el número de fotogramas dado por la propiedad Error.stackTraceLimit, lo que sea menor.

`Error.captureStackTrace(targetObject[, constructorOpt])`

targetObject <Object>
constructorOpt <Function>

Crea una propiedad .stack en targetObject, que cuando se accede devuelve una cadena que representa la ubicación en el código en la que se llamó a Error.captureStackTrace().

const myObject = {};
Error.captureStackTrace(myObject);
myObject.stack;  // Similar a `new Error().stack`

La primera línea del rastreo tendrá el prefijo ${myObject.name}: ${myObject.message}.

El argumento opcional constructorOpt acepta una función. Si se proporciona, todos los fotogramas por encima de constructorOpt, incluido constructorOpt, se omitirán del rastreo de pila generado.

El argumento constructorOpt es útil para ocultar los detalles de implementación de la generación de errores al usuario. Por ejemplo:

function a() {
  b();
}

function b() {
  c();
}

function c() {
  // Create an error without stack trace to avoid calculating the stack trace twice.
  const { stackTraceLimit } = Error;
  Error.stackTraceLimit = 0;
  const error = new Error();
  Error.stackTraceLimit = stackTraceLimit;

  // Capture the stack trace above function b
  Error.captureStackTrace(error, b); // Neither function c, nor b is included in the stack trace
  throw error;
}

a();

`Error.stackTraceLimit`

<number>

La propiedad Error.stackTraceLimit especifica el número de marcos de pila recopilados por un seguimiento de pila (ya sea generado por new Error().stack o Error.captureStackTrace(obj)).

El valor predeterminado es 10, pero se puede establecer en cualquier número JavaScript válido. Los cambios afectarán a cualquier seguimiento de pila capturado después de que se haya cambiado el valor.

Si se establece en un valor que no sea un número, o si se establece en un número negativo, los seguimientos de pila no capturarán ningún marco.

`error.cause`

Agregado en: v16.9.0

<any>

Si está presente, la propiedad error.cause es la causa subyacente del Error. Se utiliza al detectar un error y lanzar uno nuevo con un mensaje o código diferente para seguir teniendo acceso al error original.

La propiedad error.cause normalmente se establece llamando a new Error(message, { cause }). No se establece mediante el constructor si no se proporciona la opción cause.

Esta propiedad permite encadenar errores. Al serializar objetos Error, util.inspect() serializa recursivamente error.cause si está establecida.

const cause = new Error('El servidor HTTP remoto respondió con un estado 500');
const symptom = new Error('No se pudo enviar el mensaje', { cause });

console.log(symptom);
// Prints:
//   Error: No se pudo enviar el mensaje
//       at REPL2:1:17
//       at Script.runInThisContext (node:vm:130:12)
//       ... 7 líneas que coinciden con el seguimiento de pila de la causa ...
//       at [_line] [as _line] (node:internal/readline/interface:886:18) {
//     [cause]: Error: El servidor HTTP remoto respondió con un estado 500
//         at REPL1:1:15
//         at Script.runInThisContext (node:vm:130:12)
//         at REPLServer.defaultEval (node:repl:574:29)
//         at bound (node:domain:426:15)
//         at REPLServer.runBound [as eval] (node:domain:437:12)
//         at REPLServer.onLine (node:repl:902:10)
//         at REPLServer.emit (node:events:549:35)
//         at REPLServer.emit (node:domain:482:12)
//         at [_onLine] [as _onLine] (node:internal/readline/interface:425:12)
//         at [_line] [as _line] (node:internal/readline/interface:886:18)

`error.code`

<string>

La propiedad error.code es una etiqueta de cadena que identifica el tipo de error. error.code es la forma más estable de identificar un error. Solo cambiará entre versiones principales de Node.js. Por el contrario, las cadenas error.message pueden cambiar entre cualquier versión de Node.js. Consulte Códigos de error de Node.js para obtener detalles sobre códigos específicos.

`error.message`

<string>

La propiedad error.message es la descripción en cadena del error tal como se establece al llamar a new Error(message). El message pasado al constructor también aparecerá en la primera línea del rastreo de la pila del Error, sin embargo, cambiar esta propiedad después de que se crea el objeto Error puede no cambiar la primera línea del rastreo de la pila (por ejemplo, cuando se lee error.stack antes de que se cambie esta propiedad).

const err = new Error('El mensaje');
console.error(err.message);
// Imprime: El mensaje

`error.stack`

<string>

La propiedad error.stack es una cadena que describe el punto en el código en el que se instanció el Error.

bash

Error: ¡Las cosas siguen sucediendo!
   at /home/gbusey/file.js:525:2
   at Frobnicator.refrobulate (/home/gbusey/business-logic.js:424:21)
   at Actor.<anonymous> (/home/gbusey/actors.js:400:8)
   at increaseSynergy (/home/gbusey/actors.js:701:6)

La primera línea tiene el formato \<nombre de clase de error\>: \<mensaje de error\>, y le sigue una serie de marcos de pila (cada línea comienza con "at "). Cada marco describe un sitio de llamada dentro del código que condujo a la generación del error. V8 intenta mostrar un nombre para cada función (por nombre de variable, nombre de función o nombre de método de objeto), pero ocasionalmente no podrá encontrar un nombre adecuado. Si V8 no puede determinar un nombre para la función, solo se mostrará información de ubicación para ese marco. De lo contrario, el nombre de función determinado se mostrará con la información de ubicación adjunta entre paréntesis.

Los marcos solo se generan para funciones de JavaScript. Si, por ejemplo, la ejecución pasa sincrónicamente a través de una función de complemento C++ llamada cheetahify que a su vez llama a una función de JavaScript, el marco que representa la llamada cheetahify no estará presente en los rastreos de la pila:

const cheetahify = require('./native-binding.node');

function makeFaster() {
  // `cheetahify()` llama *sincrónicamente* a speedy.
  cheetahify(function speedy() {
    throw new Error('¡oh no!');
  });
}

makeFaster();
// lanzará:
//   /home/gbusey/file.js:6
//       throw new Error('¡oh no!');
//           ^
//   Error: ¡oh no!
//       at speedy (/home/gbusey/file.js:6:11)
//       at makeFaster (/home/gbusey/file.js:5:3)
//       at Object.<anonymous> (/home/gbusey/file.js:10:1)
//       at Module._compile (module.js:456:26)
//       at Object.Module._extensions..js (module.js:474:10)
//       at Module.load (module.js:356:32)
//       at Function.Module._load (module.js:312:12)
//       at Function.Module.runMain (module.js:497:10)
//       at startup (node.js:119:16)
//       at node.js:906:3

La información de ubicación será una de las siguientes:

native, si el marco representa una llamada interna a V8 (como en [].forEach).
plain-filename.js:line:column, si el marco representa una llamada interna a Node.js.
/absolute/path/to/file.js:line:column, si el marco representa una llamada en un programa de usuario (utilizando el sistema de módulos CommonJS) o sus dependencias.
\<transport-protocol\>:///url/to/module/file.mjs:line:column, si el marco representa una llamada en un programa de usuario (utilizando el sistema de módulos ES) o sus dependencias.

La cadena que representa el rastreo de la pila se genera de forma diferida cuando se accede a la propiedad error.stack.

El número de marcos capturados por el rastreo de la pila está limitado por el menor de Error.stackTraceLimit o el número de marcos disponibles en el tick actual del bucle de eventos.

Clase: `AssertionError`

Extiende: <errors.Error>

Indica el fallo de una aserción. Para obtener más detalles, consulta Class: assert.AssertionError.

Clase: `RangeError`

Extiende: <errors.Error>

Indica que un argumento proporcionado no estaba dentro del conjunto o rango de valores aceptables para una función; ya sea un rango numérico o fuera del conjunto de opciones para un parámetro de función dado.

require('node:net').connect(-1);
// Lanza "RangeError: "port" option should be >= 0 and < 65536: -1"

Node.js generará y lanzará instancias de RangeError inmediatamente como una forma de validación de argumentos.

Clase: `ReferenceError`

Extiende: <errors.Error>

Indica que se está intentando acceder a una variable que no está definida. Tales errores comúnmente indican errores tipográficos en el código, o un programa roto de otra manera.

Si bien el código del cliente puede generar y propagar estos errores, en la práctica, solo V8 lo hará.

doesNotExist;
// Lanza ReferenceError, doesNotExist no es una variable en este programa.

A menos que una aplicación esté generando y ejecutando código dinámicamente, las instancias de ReferenceError indican un error en el código o sus dependencias.

Clase: `SyntaxError`

Extiende: <errors.Error>

Indica que un programa no es JavaScript válido. Estos errores solo pueden generarse y propagarse como resultado de la evaluación del código. La evaluación del código puede ocurrir como resultado de eval, Function, require o vm. Estos errores son casi siempre indicativos de un programa roto.

try {
  require('node:vm').runInThisContext('binary ! isNotOk');
} catch (err) {
  // 'err' será un SyntaxError.
}

Las instancias de SyntaxError son irrecuperables en el contexto que las creó; solo pueden ser capturadas por otros contextos.

Clase: `SystemError`

Extiende: <errors.Error>

Node.js genera errores del sistema cuando ocurren excepciones dentro de su entorno de tiempo de ejecución. Estos generalmente ocurren cuando una aplicación viola una restricción del sistema operativo. Por ejemplo, ocurrirá un error del sistema si una aplicación intenta leer un archivo que no existe.

address <string> Si está presente, la dirección a la que falló una conexión de red
code <string> El código de error de cadena
dest <string> Si está presente, la ruta del archivo de destino al informar un error del sistema de archivos
errno <number> El número de error proporcionado por el sistema
info <Object> Si está presente, detalles adicionales sobre la condición de error
message <string> Una descripción del error legible por humanos proporcionada por el sistema
path <string> Si está presente, la ruta del archivo al informar un error del sistema de archivos
port <number> Si está presente, el puerto de conexión de red que no está disponible
syscall <string> El nombre de la llamada al sistema que activó el error

`error.address`

<string>

Si está presente, error.address es una cadena que describe la dirección a la que falló una conexión de red.

`error.code`

<string>

La propiedad error.code es una cadena que representa el código de error.

`error.dest`

<string>

Si está presente, error.dest es la ruta de destino del archivo al informar un error del sistema de archivos.

`error.errno`

<number>

La propiedad error.errno es un número negativo que corresponde al código de error definido en Manejo de errores de libuv.

En Windows, el número de error proporcionado por el sistema será normalizado por libuv.

Para obtener la representación de cadena del código de error, use util.getSystemErrorName(error.errno).

`error.info`

<Object>

Si está presente, error.info es un objeto con detalles sobre la condición de error.

`error.message`

<string>

error.message es una descripción del error legible por humanos proporcionada por el sistema.

`error.path`

<string>

Si está presente, error.path es una cadena que contiene un nombre de ruta no válido relevante.

`error.port`

<number>

Si está presente, error.port es el puerto de conexión de red que no está disponible.

`error.syscall`

<string>

La propiedad error.syscall es una cadena que describe la llamada al sistema que falló.

Errores comunes del sistema

Esta es una lista de errores del sistema que se encuentran comúnmente al escribir un programa Node.js. Para obtener una lista completa, consulte la página del manual errno(3).

EACCES (Permiso denegado): Se intentó acceder a un archivo de una manera prohibida por sus permisos de acceso al archivo.
EADDRINUSE (Dirección ya en uso): Un intento de enlazar un servidor (net, http o https) a una dirección local falló debido a que otro servidor en el sistema local ya ocupaba esa dirección.
ECONNREFUSED (Conexión rechazada): No se pudo realizar ninguna conexión porque la máquina de destino la rechazó activamente. Esto generalmente resulta de intentar conectarse a un servicio que está inactivo en el host externo.
ECONNRESET (Conexión restablecida por el par): Un par cerró una conexión por la fuerza. Esto normalmente resulta de una pérdida de la conexión en el socket remoto debido a un tiempo de espera o reinicio. Se encuentra comúnmente a través de los módulos http y net.
EEXIST (El archivo existe): Un archivo existente era el objetivo de una operación que requería que el objetivo no existiera.
EISDIR (Es un directorio): Una operación esperaba un archivo, pero la ruta dada era un directorio.
EMFILE (Demasiados archivos abiertos en el sistema): Se ha alcanzado el número máximo de descriptores de archivos permitidos en el sistema, y las solicitudes de otro descriptor no se pueden cumplir hasta que se haya cerrado al menos uno. Esto se encuentra al abrir muchos archivos a la vez en paralelo, especialmente en sistemas (en particular, macOS) donde hay un límite bajo de descriptores de archivos para los procesos. Para solucionar un límite bajo, ejecute ulimit -n 2048 en el mismo shell que ejecutará el proceso de Node.js.
ENOENT (No existe tal archivo o directorio): Comúnmente generado por las operaciones de fs para indicar que un componente de la ruta especificada no existe. No se pudo encontrar ninguna entidad (archivo o directorio) por la ruta dada.
ENOTDIR (No es un directorio): Un componente de la ruta dada existía, pero no era un directorio como se esperaba. Comúnmente generado por fs.readdir.
ENOTEMPTY (Directorio no vacío): Un directorio con entradas era el objetivo de una operación que requiere un directorio vacío, generalmente fs.unlink.
ENOTFOUND (Error de búsqueda de DNS): Indica un error de DNS de EAI_NODATA o EAI_NONAME. Este no es un error POSIX estándar.
EPERM (Operación no permitida): Se intentó realizar una operación que requiere privilegios elevados.
EPIPE (Tubería rota): Una escritura en una tubería, socket o FIFO para la cual no hay ningún proceso para leer los datos. Se encuentra comúnmente en las capas net y http, lo que indica que el lado remoto de la transmisión a la que se está escribiendo se ha cerrado.
ETIMEDOUT (Tiempo de espera agotado de la operación): Una solicitud de conexión o envío falló porque la parte conectada no respondió correctamente después de un período de tiempo. Generalmente encontrado por http o net. A menudo es una señal de que no se llamó correctamente a socket.end().

Clase: `TypeError`

Extiende <errors.Error>

Indica que un argumento proporcionado no es un tipo permitido. Por ejemplo, pasar una función a un parámetro que espera una cadena sería un TypeError.

require('node:url').parse(() => { });
// Lanza TypeError, ya que esperaba una cadena.

Node.js generará y lanzará instancias de TypeError inmediatamente como una forma de validación de argumentos.

Excepciones vs. errores

Una excepción de JavaScript es un valor que se lanza como resultado de una operación no válida o como el objetivo de una declaración throw. Si bien no es obligatorio que estos valores sean instancias de Error o clases que hereden de Error, todas las excepciones lanzadas por Node.js o el tiempo de ejecución de JavaScript serán instancias de Error.

Algunas excepciones son irrecuperables en la capa de JavaScript. Tales excepciones siempre harán que el proceso de Node.js falle. Los ejemplos incluyen comprobaciones de assert() o llamadas a abort() en la capa C++.

Errores de OpenSSL

Los errores que se originan en crypto o tls son de clase Error y, además de las propiedades estándar .code y .message, pueden tener algunas propiedades adicionales específicas de OpenSSL.

`error.opensslErrorStack`

Un array de errores que puede dar contexto a dónde se origina un error en la biblioteca OpenSSL.

`error.function`

La función de OpenSSL en la que se origina el error.

`error.library`

La biblioteca de OpenSSL en la que se origina el error.

`error.reason`

Una cadena legible por humanos que describe el motivo del error.

Códigos de error de Node.js

`ABORT_ERR`

Agregado en: v15.0.0

Se utiliza cuando una operación se ha abortado (normalmente utilizando un AbortController).

Las API que no utilizan AbortSignal normalmente no generan un error con este código.

Este código no utiliza la convención regular ERR_* que utilizan los errores de Node.js para ser compatible con AbortError de la plataforma web.

`ERR_ACCESS_DENIED`

Un tipo especial de error que se activa cada vez que Node.js intenta obtener acceso a un recurso restringido por el Modelo de Permisos.

`ERR_AMBIGUOUS_ARGUMENT`

Un argumento de función se está utilizando de una manera que sugiere que la firma de la función puede no entenderse. Esto lo lanza el módulo node:assert cuando el parámetro message en assert.throws(block, message) coincide con el mensaje de error lanzado por block porque ese uso sugiere que el usuario cree que message es el mensaje esperado en lugar del mensaje que AssertionError mostrará si block no lanza.

`ERR_ARG_NOT_ITERABLE`

Se requirió un argumento iterable (es decir, un valor que funcione con los bucles for...of), pero no se proporcionó a una API de Node.js.

`ERR_ASSERTION`

Un tipo especial de error que puede activarse cuando Node.js detecta una violación lógica excepcional que nunca debería ocurrir. Estos son lanzados típicamente por el módulo node:assert.

`ERR_ASYNC_CALLBACK`

Se intentó registrar algo que no es una función como una devolución de llamada AsyncHooks.

`ERR_ASYNC_TYPE`

El tipo de un recurso asíncrono no era válido. Los usuarios también pueden definir sus propios tipos si utilizan la API pública de incrustación.

`ERR_BROTLI_COMPRESSION_FAILED`

Los datos pasados a un flujo Brotli no se comprimieron correctamente.

`ERR_BROTLI_INVALID_PARAM`

Se pasó una clave de parámetro no válida durante la construcción de un flujo Brotli.

`ERR_BUFFER_CONTEXT_NOT_AVAILABLE`

Se intentó crear una instancia de Node.js Buffer a partir de código de complementos o incrustador, mientras que en un Contexto del motor JS que no está asociado con una instancia de Node.js. Los datos pasados al método Buffer se habrán liberado cuando el método regrese.

Cuando se encuentra este error, una posible alternativa a la creación de una instancia de Buffer es crear un Uint8Array normal, que solo difiere en el prototipo del objeto resultante. Los Uint8Array son generalmente aceptados en todas las API centrales de Node.js donde están los Buffer; están disponibles en todos los Contextos.

`ERR_BUFFER_OUT_OF_BOUNDS`

Se intentó realizar una operación fuera de los límites de un Buffer.

`ERR_BUFFER_TOO_LARGE`

Se ha intentado crear un Buffer más grande que el tamaño máximo permitido.

`ERR_CANNOT_WATCH_SIGINT`

Node.js no pudo detectar la señal SIGINT.

`ERR_CHILD_CLOSED_BEFORE_REPLY`

Un proceso hijo se cerró antes de que el padre recibiera una respuesta.

`ERR_CHILD_PROCESS_IPC_REQUIRED`

Se utiliza cuando un proceso hijo se está bifurcando sin especificar un canal IPC.

`ERR_CHILD_PROCESS_STDIO_MAXBUFFER`

Se utiliza cuando el proceso principal intenta leer datos del STDERR/STDOUT del proceso hijo, y la longitud de los datos es mayor que la opción maxBuffer.

`ERR_CLOSED_MESSAGE_PORT`

[Historia]

Versión	Cambios
v16.2.0, v14.17.1	Se reintrodujo el mensaje de error.
v11.12.0	Se eliminó el mensaje de error.
v10.5.0	Añadido en: v10.5.0

Hubo un intento de usar una instancia MessagePort en un estado cerrado, generalmente después de que se ha llamado a .close().

`ERR_CONSOLE_WRITABLE_STREAM`

Console se instanció sin un flujo stdout, o Console tiene un flujo stdout o stderr no grabable.

`ERR_CONSTRUCT_CALL_INVALID`

Añadido en: v12.5.0

Se llamó a un constructor de clase que no es invocable.

`ERR_CONSTRUCT_CALL_REQUIRED`

Se llamó a un constructor para una clase sin new.

`ERR_CONTEXT_NOT_INITIALIZED`

El contexto de vm pasado a la API aún no está inicializado. Esto podría suceder cuando ocurre un error (y se detecta) durante la creación del contexto, por ejemplo, cuando falla la asignación o se alcanza el tamaño máximo de la pila de llamadas cuando se crea el contexto.

`ERR_CRYPTO_CUSTOM_ENGINE_NOT_SUPPORTED`

Se solicitó un motor OpenSSL (por ejemplo, a través de las opciones TLS clientCertEngine o privateKeyEngine) que no es compatible con la versión de OpenSSL que se está utilizando, probablemente debido al indicador de tiempo de compilación OPENSSL_NO_ENGINE.

`ERR_CRYPTO_ECDH_INVALID_FORMAT`

Se pasó un valor no válido para el argumento format al método getPublicKey() de la clase crypto.ECDH().

`ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY`

Se ha pasado un valor no válido para el argumento key al método computeSecret() de la clase crypto.ECDH(). Significa que la clave pública se encuentra fuera de la curva elíptica.

`ERR_CRYPTO_ENGINE_UNKNOWN`

Se pasó un identificador de motor criptográfico no válido a require('node:crypto').setEngine().

`ERR_CRYPTO_FIPS_FORCED`

Se usó el argumento de línea de comandos --force-fips, pero hubo un intento de habilitar o deshabilitar el modo FIPS en el módulo node:crypto.

`ERR_CRYPTO_FIPS_UNAVAILABLE`

Se intentó habilitar o deshabilitar el modo FIPS, pero el modo FIPS no estaba disponible.

`ERR_CRYPTO_HASH_FINALIZED`

hash.digest() se llamó varias veces. El método hash.digest() no debe llamarse más de una vez por instancia de un objeto Hash.

`ERR_CRYPTO_HASH_UPDATE_FAILED`

hash.update() falló por alguna razón. Esto rara vez, o nunca, debería suceder.

`ERR_CRYPTO_INCOMPATIBLE_KEY`

Las claves criptográficas dadas son incompatibles con la operación intentada.

`ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS`

La codificación de clave pública o privada seleccionada es incompatible con otras opciones.

`ERR_CRYPTO_INITIALIZATION_FAILED`

Agregado en: v15.0.0

Falló la inicialización del subsistema criptográfico.

`ERR_CRYPTO_INVALID_AUTH_TAG`

Agregado en: v15.0.0

Se proporcionó una etiqueta de autenticación no válida.

`ERR_CRYPTO_INVALID_COUNTER`

Agregado en: v15.0.0

Se proporcionó un contador no válido para un cifrado en modo contador.

`ERR_CRYPTO_INVALID_CURVE`

Agregado en: v15.0.0

Se proporcionó una curva elíptica no válida.

El tipo del objeto de clave criptográfica proporcionado no es válido para la operación intentada.

`ERR_CRYPTO_INVALID_MESSAGELEN`

Agregado en: v15.0.0

Se proporcionó una longitud de mensaje no válida.

`ERR_CRYPTO_INVALID_SCRYPT_PARAMS`

Node.js se compiló sin soporte para scrypt. No es posible con los binarios de lanzamiento oficiales, pero puede ocurrir con compilaciones personalizadas, incluidas las compilaciones de distribución.

`ERR_CRYPTO_SIGN_KEY_REQUIRED`

No se proporcionó una clave de firma al método sign.sign().

`ERR_CRYPTO_TIMING_SAFE_EQUAL_LENGTH`

Se llamó a crypto.timingSafeEqual() con argumentos Buffer, TypedArray o DataView de diferentes longitudes.

`ERR_CRYPTO_UNKNOWN_CIPHER`

Se especificó un cifrado desconocido.

`ERR_CRYPTO_UNKNOWN_DH_GROUP`

Se proporcionó un nombre de grupo Diffie-Hellman desconocido. Consulte crypto.getDiffieHellman() para obtener una lista de nombres de grupo válidos.

`ERR_CRYPTO_UNSUPPORTED_OPERATION`

Agregado en: v15.0.0, v14.18.0

Se intentó invocar una operación criptográfica no admitida.

`ERR_DEBUGGER_ERROR`

Agregado en: v16.4.0, v14.17.4

Se produjo un error con el depurador.

`ERR_DEBUGGER_STARTUP_ERROR`

Agregado en: v16.4.0, v14.17.4

El depurador agotó el tiempo de espera mientras esperaba que el host/puerto requerido estuviera libre.

`ERR_DIR_CLOSED`

El fs.Dir se cerró previamente.

`ERR_DIR_CONCURRENT_OPERATION`

Agregado en: v14.3.0

Se intentó una llamada síncrona de lectura o cierre en un fs.Dir que tiene operaciones asíncronas en curso.

`ERR_DLOPEN_DISABLED`

Agregado en: v16.10.0, v14.19.0

Se ha deshabilitado la carga de complementos nativos utilizando --no-addons.

`ERR_DLOPEN_FAILED`

Agregado en: v15.0.0

Falló una llamada a process.dlopen().

`ERR_DNS_SET_SERVERS_FAILED`

c-ares no pudo configurar el servidor DNS.

`ERR_DOMAIN_CALLBACK_NOT_AVAILABLE`

El módulo node:domain no era utilizable ya que no pudo establecer los hooks de manejo de errores requeridos, porque process.setUncaughtExceptionCaptureCallback() había sido llamado en un momento anterior.

`ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE`

No se pudo llamar a process.setUncaughtExceptionCaptureCallback() porque el módulo node:domain se había cargado en un momento anterior.

El stack trace se extiende para incluir el momento en que se cargó el módulo node:domain.

`ERR_DUPLICATE_STARTUP_SNAPSHOT_MAIN_FUNCTION`

No se pudo llamar a v8.startupSnapshot.setDeserializeMainFunction() porque ya se había llamado antes.

`ERR_ENCODING_INVALID_ENCODED_DATA`

Los datos proporcionados a la API TextDecoder() no eran válidos según la codificación proporcionada.

`ERR_ENCODING_NOT_SUPPORTED`

La codificación proporcionada a la API TextDecoder() no era una de las Codificaciones Soportadas por WHATWG.

`ERR_EVAL_ESM_CANNOT_PRINT`

--print no se puede utilizar con entradas ESM.

`ERR_EVENT_RECURSION`

Se lanza cuando se intenta despachar recursivamente un evento en EventTarget.

`ERR_EXECUTION_ENVIRONMENT_NOT_AVAILABLE`

El contexto de ejecución de JS no está asociado con un entorno Node.js. Esto puede ocurrir cuando Node.js se utiliza como una biblioteca integrada y algunos ganchos para el motor de JS no están configurados correctamente.

`ERR_FALSY_VALUE_REJECTION`

Una Promise que fue callbackificada a través de util.callbackify() fue rechazada con un valor falsy.

`ERR_FEATURE_UNAVAILABLE_ON_PLATFORM`

Agregado en: v14.0.0

Se intentó copiar a un tipo de archivo desconocido con fs.cp().

`ERR_FS_EISDIR`

La ruta es un directorio.

`ERR_FS_FILE_TOO_LARGE`

Se ha intentado leer un archivo cuyo tamaño es mayor que el tamaño máximo permitido para un Buffer.

`ERR_HTTP2_ALTSVC_INVALID_ORIGIN`

Los marcos HTTP/2 ALTSVC requieren un origen válido.

`ERR_HTTP2_ALTSVC_LENGTH`

Los marcos HTTP/2 ALTSVC están limitados a un máximo de 16,382 bytes de carga útil.

`ERR_HTTP2_CONNECT_AUTHORITY`

Para las solicitudes HTTP/2 que usan el método CONNECT, se requiere el pseudoencabezado :authority.

`ERR_HTTP2_CONNECT_PATH`

Para las solicitudes HTTP/2 que usan el método CONNECT, el pseudoencabezado :path está prohibido.

`ERR_HTTP2_CONNECT_SCHEME`

Para las solicitudes HTTP/2 que usan el método CONNECT, el pseudoencabezado :scheme está prohibido.

`ERR_HTTP2_ERROR`

Se ha producido un error HTTP/2 no específico.

`ERR_HTTP2_GOAWAY_SESSION`

No se pueden abrir nuevos Streams HTTP/2 después de que la Http2Session haya recibido un marco GOAWAY del par conectado.

`ERR_HTTP2_HEADERS_AFTER_RESPOND`

Se especificaron encabezados adicionales después de que se iniciara una respuesta HTTP/2.

`ERR_HTTP2_HEADERS_SENT`

Se intentó enviar varios encabezados de respuesta.

`ERR_HTTP2_HEADER_SINGLE_VALUE`

Se proporcionaron varios valores para un campo de encabezado HTTP/2 que debía tener solo un valor.

`ERR_HTTP2_INFO_STATUS_NOT_ALLOWED`

Los códigos de estado HTTP informativos (1xx) no se pueden establecer como el código de estado de respuesta en las respuestas HTTP/2.

`ERR_HTTP2_INVALID_CONNECTION_HEADERS`

Los encabezados específicos de la conexión HTTP/1 tienen prohibido usarse en solicitudes y respuestas HTTP/2.

`ERR_HTTP2_INVALID_HEADER_VALUE`

Se especificó un valor de encabezado HTTP/2 no válido.

`ERR_HTTP2_INVALID_INFO_STATUS`

Se ha especificado un código de estado informativo HTTP no válido. Los códigos de estado informativos deben ser un entero entre 100 y 199 (inclusive).

`ERR_HTTP2_INVALID_ORIGIN`

Los marcos ORIGIN de HTTP/2 requieren un origen válido.

`ERR_HTTP2_INVALID_PACKED_SETTINGS_LENGTH`

Las instancias de Buffer y Uint8Array pasadas a la API http2.getUnpackedSettings() deben tener una longitud que sea múltiplo de seis.

`ERR_HTTP2_INVALID_PSEUDOHEADER`

Solo se pueden usar pseudoencabezados HTTP/2 válidos (:status, :path, :authority, :scheme y :method).

`ERR_HTTP2_INVALID_SESSION`

Se realizó una acción en un objeto Http2Session que ya había sido destruido.

`ERR_HTTP2_INVALID_SETTING_VALUE`

Se ha especificado un valor no válido para una configuración HTTP/2.

`ERR_HTTP2_INVALID_STREAM`

Se realizó una operación en un flujo que ya había sido destruido.

`ERR_HTTP2_MAX_PENDING_SETTINGS_ACK`

Cada vez que se envía un marco SETTINGS de HTTP/2 a un par conectado, se requiere que el par envíe un acuse de recibo de que ha recibido y aplicado la nueva SETTINGS. Por defecto, se puede enviar un número máximo de marcos SETTINGS no reconocidos en un momento dado. Este código de error se utiliza cuando se ha alcanzado ese límite.

`ERR_HTTP2_NESTED_PUSH`

Se intentó iniciar un nuevo flujo push desde dentro de un flujo push. No se permiten flujos push anidados.

`ERR_HTTP2_NO_MEM`

Sin memoria al usar la API http2session.setLocalWindowSize(windowSize).

`ERR_HTTP2_NO_SOCKET_MANIPULATION`

Se intentó manipular directamente (leer, escribir, pausar, reanudar, etc.) un socket adjunto a un Http2Session.

`ERR_HTTP2_ORIGIN_LENGTH`

Los marcos ORIGIN de HTTP/2 están limitados a una longitud de 16382 bytes.

`ERR_HTTP2_OUT_OF_STREAMS`

El número de flujos creados en una sola sesión HTTP/2 alcanzó el límite máximo.

`ERR_HTTP2_PAYLOAD_FORBIDDEN`

Se especificó una carga útil de mensaje para un código de respuesta HTTP para el cual está prohibida una carga útil.

`ERR_HTTP2_PING_CANCEL`

Un ping HTTP/2 fue cancelado.

`ERR_HTTP2_PING_LENGTH`

Las cargas útiles de ping HTTP/2 deben tener exactamente 8 bytes de longitud.

`ERR_HTTP2_PSEUDOHEADER_NOT_ALLOWED`

Se ha utilizado un pseudoencabezado HTTP/2 de forma inapropiada. Los pseudoencabezados son nombres de clave de encabezado que comienzan con el prefijo :.

`ERR_HTTP2_PUSH_DISABLED`

Se intentó crear un flujo push, que había sido deshabilitado por el cliente.

`ERR_HTTP2_SEND_FILE`

Se intentó utilizar la API Http2Stream.prototype.responseWithFile() para enviar un directorio.

`ERR_HTTP2_SEND_FILE_NOSEEK`

Se intentó utilizar la API Http2Stream.prototype.responseWithFile() para enviar algo que no es un archivo regular, pero se proporcionaron las opciones offset o length.

`ERR_HTTP2_SESSION_ERROR`

La Http2Session se cerró con un código de error distinto de cero.

`ERR_HTTP2_SETTINGS_CANCEL`

La configuración de Http2Session fue cancelada.

`ERR_HTTP2_SOCKET_BOUND`

Se intentó conectar un objeto Http2Session a un net.Socket o tls.TLSSocket que ya se había vinculado a otro objeto Http2Session.

`ERR_HTTP2_SOCKET_UNBOUND`

Se intentó utilizar la propiedad socket de una Http2Session que ya ha sido cerrada.

`ERR_HTTP2_STATUS_101`

El uso del código de estado informativo 101 está prohibido en HTTP/2.

`ERR_HTTP2_STATUS_INVALID`

Se ha especificado un código de estado HTTP no válido. Los códigos de estado deben ser un entero entre 100 y 599 (inclusive).

`ERR_HTTP2_STREAM_CANCEL`

Un Http2Stream fue destruido antes de que se transmitieran datos al peer conectado.

`ERR_HTTP2_STREAM_ERROR`

Se especificó un código de error distinto de cero en un frame RST_STREAM.

`ERR_HTTP2_STREAM_SELF_DEPENDENCY`

Al establecer la prioridad para un flujo HTTP/2, el flujo puede marcarse como una dependencia para un flujo primario. Este código de error se utiliza cuando se intenta marcar un flujo como dependiente de sí mismo.

`ERR_HTTP2_TOO_MANY_CUSTOM_SETTINGS`

Se ha excedido el número de configuraciones personalizadas admitidas (10).

`ERR_HTTP2_TOO_MANY_INVALID_FRAMES`

Añadido en: v15.14.0

Se ha excedido el límite de tramas de protocolo HTTP/2 no válidas aceptables enviadas por el par, según se especifica mediante la opción maxSessionInvalidFrames.

`ERR_HTTP2_TRAILERS_ALREADY_SENT`

Los encabezados finales ya se han enviado en el Http2Stream.

`ERR_HTTP2_TRAILERS_NOT_READY`

El método http2stream.sendTrailers() no se puede llamar hasta después de que se emita el evento 'wantTrailers' en un objeto Http2Stream. El evento 'wantTrailers' solo se emitirá si la opción waitForTrailers está configurada para el Http2Stream.

`ERR_HTTP2_UNSUPPORTED_PROTOCOL`

Se pasó a http2.connect() una URL que utiliza cualquier protocolo que no sea http: o https:.

`ERR_HTTP_BODY_NOT_ALLOWED`

Se produce un error al escribir en una respuesta HTTP que no permite contenido.

`ERR_HTTP_CONTENT_LENGTH_MISMATCH`

El tamaño del cuerpo de la respuesta no coincide con el valor del encabezado content-length especificado.

`ERR_HTTP_HEADERS_SENT`

Se intentó agregar más encabezados después de que ya se habían enviado los encabezados.

`ERR_HTTP_INVALID_HEADER_VALUE`

Se especificó un valor de encabezado HTTP no válido.

`ERR_HTTP_INVALID_STATUS_CODE`

El código de estado estaba fuera del rango de código de estado regular (100-999).

`ERR_HTTP_REQUEST_TIMEOUT`

El cliente no ha enviado la solicitud completa dentro del tiempo permitido.

`ERR_HTTP_SOCKET_ASSIGNED`

Al ServerResponse dado ya se le asignó un socket.

`ERR_HTTP_SOCKET_ENCODING`

No se permite cambiar la codificación del socket según la RFC 7230 Sección 3.

`ERR_HTTP_TRAILER_INVALID`

El encabezado Trailer se estableció aunque la codificación de transferencia no lo admita.

`ERR_ILLEGAL_CONSTRUCTOR`

Se intentó construir un objeto utilizando un constructor no público.

`ERR_IMPORT_ATTRIBUTE_MISSING`

Añadido en: v21.1.0

Falta un atributo de importación, lo que impide que se importe el módulo especificado.

`ERR_IMPORT_ATTRIBUTE_TYPE_INCOMPATIBLE`

Añadido en: v21.1.0

Se proporcionó un atributo type de importación, pero el módulo especificado es de un tipo diferente.

`ERR_IMPORT_ATTRIBUTE_UNSUPPORTED`

Añadido en: v21.0.0, v20.10.0, v18.19.0

Esta versión de Node.js no admite un atributo de importación.

`ERR_INCOMPATIBLE_OPTION_PAIR`

Un par de opciones es incompatible entre sí y no se puede utilizar al mismo tiempo.

`ERR_INPUT_TYPE_NOT_ALLOWED`

[Estable: 1 - Experimental]

Estable: 1 Estabilidad: 1 - Experimental

Se utilizó la bandera --input-type para intentar ejecutar un archivo. Esta bandera solo se puede utilizar con la entrada a través de --eval, --print o STDIN.

`ERR_INSPECTOR_ALREADY_ACTIVATED`

Mientras se utilizaba el módulo node:inspector, se intentó activar el inspector cuando ya había comenzado a escuchar en un puerto. Utilice inspector.close() antes de activarlo en una dirección diferente.

`ERR_INSPECTOR_ALREADY_CONNECTED`

Mientras se utilizaba el módulo node:inspector, se intentó conectar cuando el inspector ya estaba conectado.

`ERR_INSPECTOR_CLOSED`

Mientras se utilizaba el módulo node:inspector, se intentó utilizar el inspector después de que la sesión ya se hubiera cerrado.

`ERR_INSPECTOR_COMMAND`

Se produjo un error al emitir un comando a través del módulo node:inspector.

`ERR_INSPECTOR_NOT_ACTIVE`

El inspector no está activo cuando se llama a inspector.waitForDebugger().

`ERR_INSPECTOR_NOT_AVAILABLE`

El módulo node:inspector no está disponible para su uso.

`ERR_INSPECTOR_NOT_CONNECTED`

Mientras se utilizaba el módulo node:inspector, se intentó utilizar el inspector antes de que estuviera conectado.

`ERR_INSPECTOR_NOT_WORKER`

Se llamó a una API en el hilo principal que solo se puede utilizar desde el hilo de trabajo.

`ERR_INTERNAL_ASSERTION`

Hubo un error en Node.js o un uso incorrecto de los internos de Node.js. Para solucionar el error, abra un problema en https://github.com/nodejs/node/issues.

`ERR_INVALID_ADDRESS`

La API de Node.js no entiende la dirección proporcionada.

`ERR_INVALID_ADDRESS_FAMILY`

La API de Node.js no entiende la familia de direcciones proporcionada.

`ERR_INVALID_ARG_TYPE`

Se pasó un argumento del tipo incorrecto a una API de Node.js.

`ERR_INVALID_ARG_VALUE`

Se pasó un valor no válido o no admitido para un argumento dado.

`ERR_INVALID_ASYNC_ID`

Se pasó un asyncId o triggerAsyncId no válido utilizando AsyncHooks. Un ID menor que -1 nunca debería ocurrir.

`ERR_INVALID_BUFFER_SIZE`

Se realizó un intercambio en un Buffer pero su tamaño no era compatible con la operación.

`ERR_INVALID_CHAR`

Se detectaron caracteres no válidos en los encabezados.

`ERR_INVALID_CURSOR_POS`

No se puede mover un cursor en una transmisión dada a una fila especificada sin una columna especificada.

`ERR_INVALID_FD`

Un descriptor de archivo ('fd') no era válido (p. ej., era un valor negativo).

`ERR_INVALID_FD_TYPE`

Un tipo de descriptor de archivo ('fd') no era válido.

`ERR_INVALID_FILE_URL_HOST`

Una API de Node.js que consume URL file: (como ciertas funciones en el módulo fs) encontró una URL de archivo con un host incompatible. Esta situación solo puede ocurrir en sistemas tipo Unix donde solo se admite localhost o un host vacío.

`ERR_INVALID_FILE_URL_PATH`

Una API de Node.js que consume URL file: (como ciertas funciones en el módulo fs) encontró una URL de archivo con una ruta incompatible. La semántica exacta para determinar si se puede usar una ruta depende de la plataforma.

`ERR_INVALID_HANDLE_TYPE`

Se intentó enviar un "handle" no admitido a través de un canal de comunicación IPC a un proceso hijo. Consulte subprocess.send() y process.send() para obtener más información.

`ERR_INVALID_HTTP_TOKEN`

Se proporcionó un token HTTP no válido.

`ERR_INVALID_IP_ADDRESS`

Una dirección IP no es válida.

`ERR_INVALID_MIME_SYNTAX`

La sintaxis de un MIME no es válida.

`ERR_INVALID_MODULE`

Agregado en: v15.0.0, v14.18.0

Se intentó cargar un módulo que no existe o que no era válido.

`ERR_INVALID_MODULE_SPECIFIER`

La cadena de módulo importada no es una URL, un nombre de paquete o un especificador de subruta de paquete válidos.

`ERR_INVALID_OBJECT_DEFINE_PROPERTY`

Se produjo un error al establecer un atributo no válido en la propiedad de un objeto.

`ERR_INVALID_PACKAGE_CONFIG`

Un archivo package.json no válido no se pudo analizar.

`ERR_INVALID_PACKAGE_TARGET`

El campo "exports" de package.json contiene un valor de mapeo de destino no válido para la resolución de módulo intentada.

`ERR_INVALID_PROTOCOL`

Se pasó un options.protocol no válido a http.request().

`ERR_INVALID_REPL_EVAL_CONFIG`

Se establecieron las opciones breakEvalOnSigint y eval en la configuración de REPL, lo cual no es compatible.

`ERR_INVALID_REPL_INPUT`

La entrada no se puede usar en el REPL. Las condiciones bajo las cuales se usa este error se describen en la documentación de REPL.

`ERR_INVALID_RETURN_PROPERTY`

Se lanza en caso de que una opción de función no proporcione un valor válido para una de las propiedades de objeto devueltas en la ejecución.

`ERR_INVALID_RETURN_PROPERTY_VALUE`

Se lanza en caso de que una opción de función no proporcione un tipo de valor esperado para una de las propiedades de objeto devueltas en la ejecución.

`ERR_INVALID_RETURN_VALUE`

Se lanza en caso de que una opción de función no devuelva un tipo de valor esperado en la ejecución, como cuando se espera que una función devuelva una promesa.

`ERR_INVALID_STATE`

Agregado en: v15.0.0

Indica que una operación no se puede completar debido a un estado no válido. Por ejemplo, un objeto puede haber sido destruido o puede estar realizando otra operación.

`ERR_INVALID_SYNC_FORK_INPUT`

Se proporcionó un Buffer, TypedArray, DataView o string como entrada stdio a una bifurcación asíncrona. Consulte la documentación del módulo child_process para obtener más información.

`ERR_INVALID_THIS`

Se llamó a una función de la API de Node.js con un valor this incompatible.

const urlSearchParams = new URLSearchParams('foo=bar&baz=new');

const buf = Buffer.alloc(1);
urlSearchParams.has.call(buf, 'foo');
// Lanza un TypeError con el código 'ERR_INVALID_THIS'

`ERR_INVALID_TUPLE`

Un elemento en el iterable proporcionado al constructor URLSearchParams WHATWG no representaba una tupla [nombre, valor] – es decir, si un elemento no es iterable, o no consta exactamente de dos elementos.

`ERR_INVALID_TYPESCRIPT_SYNTAX`

Agregado en: v23.0.0

La sintaxis de TypeScript proporcionada no es válida o no es compatible. Esto podría suceder al usar la sintaxis de TypeScript que requiere transformación con eliminación de tipos.

`ERR_INVALID_URI`

Se pasó una URI no válida.

`ERR_INVALID_URL`

Se pasó una URL no válida al constructor URL WHATWG o al legado url.parse() para ser analizada. El objeto de error lanzado normalmente tiene una propiedad adicional 'input' que contiene la URL que no se pudo analizar.

`ERR_INVALID_URL_SCHEME`

Se intentó utilizar una URL de un esquema (protocolo) incompatible para un propósito específico. Solo se usa en el soporte de la API URL WHATWG en el módulo fs (que solo acepta URLs con el esquema 'file'), pero también se puede usar en otras API de Node.js en el futuro.

`ERR_IPC_CHANNEL_CLOSED`

Se intentó usar un canal de comunicación IPC que ya estaba cerrado.

`ERR_IPC_DISCONNECTED`

Se intentó desconectar un canal de comunicación IPC que ya estaba desconectado. Consulte la documentación del módulo child_process para obtener más información.

`ERR_IPC_ONE_PIPE`

Se intentó crear un proceso secundario de Node.js utilizando más de un canal de comunicación IPC. Consulte la documentación del módulo child_process para obtener más información.

`ERR_IPC_SYNC_FORK`

Se intentó abrir un canal de comunicación IPC con un proceso de Node.js bifurcado sincrónicamente. Consulte la documentación del módulo child_process para obtener más información.

`ERR_IP_BLOCKED`

IP bloqueada por net.BlockList.

`ERR_LOADER_CHAIN_INCOMPLETE`

Agregado en: v18.6.0, v16.17.0

Un hook del cargador de ESM regresó sin llamar a next() y sin señalar explícitamente un cortocircuito.

`ERR_LOAD_SQLITE_EXTENSION`

Agregado en: v23.5.0

Se produjo un error al cargar una extensión de SQLite.

`ERR_MEMORY_ALLOCATION_FAILED`

Se intentó asignar memoria (generalmente en la capa C++), pero falló.

`ERR_MESSAGE_TARGET_CONTEXT_UNAVAILABLE`

Agregado en: v14.5.0, v12.19.0

Un mensaje publicado en un MessagePort no se pudo deserializar en el Context de vm de destino. No todos los objetos de Node.js se pueden instanciar correctamente en cualquier contexto en este momento, e intentar transferirlos usando postMessage() puede fallar en el lado receptor en ese caso.

`ERR_METHOD_NOT_IMPLEMENTED`

Se requiere un método pero no se implementa.

`ERR_MISSING_ARGS`

No se pasó un argumento requerido de una API de Node.js. Esto solo se usa para el cumplimiento estricto de la especificación de la API (que en algunos casos puede aceptar func(undefined) pero no func()). En la mayoría de las API nativas de Node.js, func(undefined) y func() se tratan de forma idéntica, y el código de error ERR_INVALID_ARG_TYPE puede usarse en su lugar.

`ERR_MISSING_OPTION`

Para las API que aceptan objetos de opciones, algunas opciones podrían ser obligatorias. Este código se lanza si falta una opción requerida.

`ERR_MISSING_PASSPHRASE`

Se intentó leer una clave encriptada sin especificar una frase de contraseña.

`ERR_MISSING_PLATFORM_FOR_WORKER`

La plataforma V8 utilizada por esta instancia de Node.js no admite la creación de Workers. Esto se debe a la falta de soporte del incrustador para Workers. En particular, este error no ocurrirá con las compilaciones estándar de Node.js.

`ERR_MODULE_NOT_FOUND`

Un archivo de módulo no pudo ser resuelto por el cargador de módulos ECMAScript al intentar una operación de import o al cargar el punto de entrada del programa.

`ERR_MULTIPLE_CALLBACK`

Una función de retorno (callback) fue llamada más de una vez.

Una función de retorno casi siempre está destinada a ser llamada solo una vez, ya que la consulta puede ser satisfecha o rechazada, pero no ambas al mismo tiempo. Esto último sería posible al llamar a una función de retorno más de una vez.

`ERR_NAPI_CONS_FUNCTION`

Al usar Node-API, un constructor pasado no era una función.

`ERR_NAPI_INVALID_DATAVIEW_ARGS`

Al llamar a napi_create_dataview(), un offset dado estaba fuera de los límites de la dataview o offset + length era mayor que la longitud del buffer dado.

`ERR_NAPI_INVALID_TYPEDARRAY_ALIGNMENT`

Al llamar a napi_create_typedarray(), el offset proporcionado no era un múltiplo del tamaño del elemento.

`ERR_NAPI_INVALID_TYPEDARRAY_LENGTH`

Al llamar a napi_create_typedarray(), (length * size_of_element) + byte_offset era mayor que la longitud del buffer dado.

`ERR_NAPI_TSFN_CALL_JS`

Ocurrió un error al invocar la parte de JavaScript de la función segura para subprocesos.

`ERR_NAPI_TSFN_GET_UNDEFINED`

Ocurrió un error al intentar recuperar el valor undefined de JavaScript.

`ERR_NON_CONTEXT_AWARE_DISABLED`

Un complemento nativo no consciente del contexto se cargó en un proceso que no los permite.

`ERR_NOT_BUILDING_SNAPSHOT`

Se intentó utilizar operaciones que solo se pueden usar al construir una instantánea de inicio de V8, aunque Node.js no está construyendo una.

`ERR_NOT_IN_SINGLE_EXECUTABLE_APPLICATION`

Agregado en: v21.7.0, v20.12.0

La operación no se puede realizar cuando no está en una aplicación de un solo ejecutable.

`ERR_NOT_SUPPORTED_IN_SNAPSHOT`

Se intentó realizar operaciones que no son compatibles al construir una instantánea de inicio.

`ERR_NO_CRYPTO`

Se intentó utilizar funciones criptográficas mientras que Node.js no se compiló con soporte criptográfico OpenSSL.

`ERR_NO_ICU`

Se intentó usar características que requieren ICU, pero Node.js no se compiló con soporte para ICU.

`ERR_NO_TYPESCRIPT`

Agregado en: v23.0.0

Se intentó usar características que requieren soporte nativo de TypeScript, pero Node.js no se compiló con soporte para TypeScript.

`ERR_OPERATION_FAILED`

Agregado en: v15.0.0

Una operación falló. Esto se usa normalmente para indicar el fallo general de una operación asíncrona.

`ERR_OUT_OF_RANGE`

Un valor dado está fuera del rango aceptado.

`ERR_PACKAGE_IMPORT_NOT_DEFINED`

El campo "imports" de package.json no define la asignación del especificador de paquete interno dado.

`ERR_PACKAGE_PATH_NOT_EXPORTED`

El campo "exports" de package.json no exporta la subruta solicitada. Debido a que las exportaciones están encapsuladas, los módulos internos privados que no se exportan no se pueden importar a través de la resolución del paquete, a menos que se use una URL absoluta.

`ERR_PARSE_ARGS_INVALID_OPTION_VALUE`

Agregado en: v18.3.0, v16.17.0

Cuando strict se establece en true, util.parseArgs() lo arroja si se proporciona un valor <boolean> para una opción de tipo <string>, o si se proporciona un valor <string> para una opción de tipo <boolean>.

`ERR_PARSE_ARGS_UNEXPECTED_POSITIONAL`

Agregado en: v18.3.0, v16.17.0

Arrojado por util.parseArgs(), cuando se proporciona un argumento posicional y allowPositionals se establece en false.

`ERR_PARSE_ARGS_UNKNOWN_OPTION`

Agregado en: v18.3.0, v16.17.0

Cuando strict se establece en true, util.parseArgs() lo arroja si un argumento no está configurado en options.

`ERR_PERFORMANCE_INVALID_TIMESTAMP`

Se proporcionó un valor de marca de tiempo no válido para una marca o medida de rendimiento.

`ERR_PERFORMANCE_MEASURE_INVALID_OPTIONS`

Estable: 1 Estabilidad: 1 - Experimental

Cuando se intenta require() un Módulo ES, un borde de CommonJS a ESM o de ESM a CommonJS participa en un ciclo inmediato. Esto no está permitido porque los módulos ES no se pueden evaluar mientras ya se están evaluando.

Para evitar el ciclo, la llamada a require() involucrada en un ciclo no debe ocurrir en el nivel superior de un Módulo ES (a través de createRequire()) o un módulo CommonJS, y debe realizarse de manera diferida en una función interna.

`ERR_REQUIRE_ESM`

[Historial]

Versión	Cambios
v23.0.0	require() ahora admite la carga de módulos ES síncronos de forma predeterminada.

[Estable: 0 - Obsoleto]

Estable: 0 Estabilidad: 0 - Obsoleto

Se intentó require() un Módulo ES.

Este error ha quedado obsoleto ya que require() ahora admite la carga de módulos ES síncronos. Cuando require() encuentra un módulo ES que contiene await de nivel superior, lanzará ERR_REQUIRE_ASYNC_MODULE en su lugar.

`ERR_SCRIPT_EXECUTION_INTERRUPTED`

La ejecución del script fue interrumpida por SIGINT (Por ejemplo, se presionó +).

`ERR_SCRIPT_EXECUTION_TIMEOUT`

La ejecución del script se agotó, posiblemente debido a errores en el script que se está ejecutando.

`ERR_SERVER_ALREADY_LISTEN`

Se llamó al método server.listen() mientras que un net.Server ya estaba escuchando. Esto se aplica a todas las instancias de net.Server, incluidas las instancias Server HTTP, HTTPS y HTTP/2.

`ERR_SERVER_NOT_RUNNING`

Se llamó al método server.close() cuando un net.Server no estaba en ejecución. Esto se aplica a todas las instancias de net.Server, incluidas las instancias Server de HTTP, HTTPS y HTTP/2.

`ERR_SINGLE_EXECUTABLE_APPLICATION_ASSET_NOT_FOUND`

Añadido en: v21.7.0, v20.12.0

Se pasó una clave a las APIs de aplicación ejecutable única para identificar un activo, pero no se pudo encontrar ninguna coincidencia.

`ERR_SOCKET_ALREADY_BOUND`

Se intentó enlazar un socket que ya ha sido enlazado.

`ERR_SOCKET_BAD_BUFFER_SIZE`

Se pasó un tamaño inválido (negativo) para las opciones recvBufferSize o sendBufferSize en dgram.createSocket().

`ERR_SOCKET_BAD_PORT`

Una función API que esperaba un puerto >= 0 y < 65536 recibió un valor inválido.

`ERR_SOCKET_BAD_TYPE`

Una función API que esperaba un tipo de socket (udp4 o udp6) recibió un valor inválido.

`ERR_SOCKET_BUFFER_SIZE`

Mientras se usaba dgram.createSocket(), no se pudo determinar el tamaño del Buffer de recepción o envío.

`ERR_SOCKET_CLOSED`

Se intentó operar en un socket ya cerrado.

`ERR_SOCKET_CLOSED_BEFORE_CONNECTION`

Cuando se llama a net.Socket.write() en un socket de conexión y el socket se cierra antes de que se establezca la conexión.

`ERR_SOCKET_CONNECTION_TIMEOUT`

El socket no pudo conectarse a ninguna dirección devuelta por el DNS dentro del tiempo de espera permitido al usar el algoritmo de autoselección de familia.

`ERR_SOCKET_DGRAM_IS_CONNECTED`

Se realizó una llamada dgram.connect() en un socket ya conectado.

`ERR_SOCKET_DGRAM_NOT_CONNECTED`

Se realizó una llamada dgram.disconnect() o dgram.remoteAddress() en un socket desconectado.

`ERR_SOCKET_DGRAM_NOT_RUNNING`

Se realizó una llamada y el subsistema UDP no se estaba ejecutando.

`ERR_SOURCE_MAP_CORRUPT`

El mapa de origen no se pudo analizar porque no existe o está dañado.

`ERR_SOURCE_MAP_MISSING_SOURCE`

No se encontró un archivo importado desde un mapa de origen.

`ERR_SQLITE_ERROR`

Añadido en: v22.5.0

Se devolvió un error de SQLite.

`ERR_SRI_PARSE`

Se proporcionó una cadena para una verificación de Integridad de Subrecursos, pero no se pudo analizar. Consulte el formato de los atributos de integridad consultando la especificación de Integridad de Subrecursos.

`ERR_STREAM_ALREADY_FINISHED`

Se llamó a un método de transmisión que no se puede completar porque la transmisión finalizó.

`ERR_STREAM_CANNOT_PIPE`

Se intentó llamar a stream.pipe() en una transmisión Writable.

`ERR_STREAM_DESTROYED`

Se llamó a un método de transmisión que no se puede completar porque la transmisión se destruyó usando stream.destroy().

`ERR_STREAM_NULL_VALUES`

Se intentó llamar a stream.write() con un fragmento null.

`ERR_STREAM_PREMATURE_CLOSE`

Un error devuelto por stream.finished() y stream.pipeline(), cuando una transmisión o una canalización finaliza de forma no correcta sin un error explícito.

`ERR_STREAM_PUSH_AFTER_EOF`

Se intentó llamar a stream.push() después de que se enviara un null (EOF) a la transmisión.

`ERR_STREAM_UNABLE_TO_PIPE`

Se intentó canalizar a una transmisión cerrada o destruida en una canalización.

`ERR_STREAM_UNSHIFT_AFTER_END_EVENT`

Se intentó llamar a stream.unshift() después de que se emitiera el evento 'end'.

`ERR_STREAM_WRAP`

Evita una interrupción si se estableció un decodificador de cadenas en el Socket o si el decodificador está en objectMode.

const Socket = require('node:net').Socket;
const instance = new Socket();

instance.setEncoding('utf8');

`ERR_STREAM_WRITE_AFTER_END`

Se intentó llamar a stream.write() después de que se llamara a stream.end().

`ERR_STRING_TOO_LONG`

Se ha intentado crear una cadena de texto más larga que la longitud máxima permitida.

`ERR_SYNTHETIC`

Un objeto de error artificial utilizado para capturar la pila de llamadas para informes de diagnóstico.

`ERR_SYSTEM_ERROR`

Se ha producido un error del sistema no especificado o no específico dentro del proceso de Node.js. El objeto de error tendrá una propiedad de objeto err.info con detalles adicionales.

`ERR_TAP_LEXER_ERROR`

Un error que representa un estado de analizador léxico fallido.

`ERR_TAP_PARSER_ERROR`

Un error que representa un estado de analizador sintáctico fallido. La información adicional sobre el token que causa el error está disponible a través de la propiedad cause.

`ERR_TAP_VALIDATION_ERROR`

Este error representa una validación TAP fallida.

`ERR_TEST_FAILURE`

Este error representa una prueba fallida. La información adicional sobre el fallo está disponible a través de la propiedad cause. La propiedad failureType especifica lo que la prueba estaba haciendo cuando ocurrió el fallo.

`ERR_TLS_ALPN_CALLBACK_INVALID_RESULT`

Este error se lanza cuando una ALPNCallback devuelve un valor que no está en la lista de protocolos ALPN ofrecidos por el cliente.

`ERR_TLS_ALPN_CALLBACK_WITH_PROTOCOLS`

Este error se lanza al crear un TLSServer si las opciones TLS incluyen tanto ALPNProtocols como ALPNCallback. Estas opciones son mutuamente excluyentes.

`ERR_TLS_CERT_ALTNAME_FORMAT`

Este error lo lanza checkServerIdentity si una propiedad subjectaltname proporcionada por el usuario viola las reglas de codificación. Los objetos de certificado producidos por el propio Node.js siempre cumplen con las reglas de codificación y nunca causarán este error.

`ERR_TLS_CERT_ALTNAME_INVALID`

Al usar TLS, el nombre de host/IP del par no coincidió con ninguno de los subjectAltNames en su certificado.

`ERR_TLS_DH_PARAM_SIZE`

Al usar TLS, el parámetro ofrecido para el protocolo de acuerdo de clave Diffie-Hellman (DH) es demasiado pequeño. De forma predeterminada, la longitud de la clave debe ser mayor o igual que 1024 bits para evitar vulnerabilidades, aunque se recomienda encarecidamente utilizar 2048 bits o más para una mayor seguridad.

`ERR_TLS_HANDSHAKE_TIMEOUT`

Un handshake TLS/SSL excedió el tiempo límite. En este caso, el servidor también debe abortar la conexión.

`ERR_TLS_INVALID_CONTEXT`

Agregado en: v13.3.0

El contexto debe ser un SecureContext.

`ERR_TLS_INVALID_PROTOCOL_METHOD`

El método secureProtocol especificado no es válido. Es desconocido o está deshabilitado porque no es seguro.

`ERR_TLS_INVALID_PROTOCOL_VERSION`

Las versiones válidas del protocolo TLS son 'TLSv1', 'TLSv1.1' o 'TLSv1.2'.

`ERR_TLS_INVALID_STATE`

Agregado en: v13.10.0, v12.17.0

El socket TLS debe estar conectado y establecido de forma segura. Asegúrese de que se emita el evento 'secure' antes de continuar.

`ERR_TLS_PROTOCOL_VERSION_CONFLICT`

Intentar establecer un protocolo TLS minVersion o maxVersion entra en conflicto con un intento de establecer el secureProtocol explícitamente. Utilice un mecanismo u otro.

`ERR_TLS_PSK_SET_IDENTITY_HINT_FAILED`

No se pudo establecer la sugerencia de identidad PSK. La sugerencia puede ser demasiado larga.

`ERR_TLS_RENEGOTIATION_DISABLED`

Se intentó renegociar TLS en una instancia de socket con la renegociación deshabilitada.

`ERR_TLS_REQUIRED_SERVER_NAME`

Mientras se usaba TLS, se llamó al método server.addContext() sin proporcionar un nombre de host en el primer parámetro.

`ERR_TLS_SESSION_ATTACK`

Se detecta una cantidad excesiva de renegociaciones TLS, lo cual es un vector potencial para ataques de denegación de servicio.

`ERR_TLS_SNI_FROM_SERVER`

Se intentó emitir la Indicación de Nombre de Servidor desde un socket TLS del lado del servidor, que solo es válido desde un cliente.

`ERR_TRACE_EVENTS_CATEGORY_REQUIRED`

El método trace_events.createTracing() requiere al menos una categoría de evento de rastreo.

`ERR_TRACE_EVENTS_UNAVAILABLE`

No se pudo cargar el módulo node:trace_events porque Node.js se compiló con el indicador --without-v8-platform.

`ERR_TRANSFORM_ALREADY_TRANSFORMING`

Un flujo Transform finalizó mientras aún se estaba transformando.

`ERR_TRANSFORM_WITH_LENGTH_0`

Un flujo Transform finalizó con datos aún en el búfer de escritura.

`ERR_TTY_INIT_FAILED`

La inicialización de un TTY falló debido a un error del sistema.

`ERR_UNAVAILABLE_DURING_EXIT`

Se llamó a una función dentro de un controlador process.on('exit') que no debería llamarse dentro del controlador process.on('exit').

`ERR_UNCAUGHT_EXCEPTION_CAPTURE_ALREADY_SET`

Se llamó a process.setUncaughtExceptionCaptureCallback() dos veces, sin restablecer primero la devolución de llamada a null.

Este error está diseñado para evitar sobrescribir accidentalmente una devolución de llamada registrada desde otro módulo.

`ERR_UNESCAPED_CHARACTERS`

Se recibió una cadena que contenía caracteres sin escape.

`ERR_UNHANDLED_ERROR`

Se produjo un error no controlado (por ejemplo, cuando un evento 'error' es emitido por un EventEmitter pero no se registra un controlador 'error').

`ERR_UNKNOWN_BUILTIN_MODULE`

Se utiliza para identificar un tipo específico de error interno de Node.js que normalmente no debería ser desencadenado por el código del usuario. Las instancias de este error apuntan a un error interno dentro del propio binario de Node.js.

`ERR_UNKNOWN_CREDENTIAL`

Se pasó un identificador de grupo o usuario de Unix que no existe.

`ERR_UNKNOWN_ENCODING`

Se pasó una opción de codificación no válida o desconocida a una API.

`ERR_UNKNOWN_FILE_EXTENSION`

[Estable: 1 - Experimental]

Estable: 1 Estabilidad: 1 - Experimental

Se intentó cargar un módulo con una extensión de archivo desconocida o no admitida.

`ERR_UNKNOWN_MODULE_FORMAT`

[Estable: 1 - Experimental]

Estable: 1 Estabilidad: 1 - Experimental

Se intentó cargar un módulo con un formato desconocido o no admitido.

`ERR_UNKNOWN_SIGNAL`

Se pasó una señal de proceso no válida o desconocida a una API que espera una señal válida (como subprocess.kill()).

`ERR_UNSUPPORTED_DIR_IMPORT`

No se admite import de una URL de directorio. En su lugar, autorreferencie un paquete utilizando su nombre y defina una subruta personalizada en el campo "exports" del archivo package.json.

import './'; // no compatible
import './index.js'; // compatible
import 'package-name'; // compatible

`ERR_UNSUPPORTED_ESM_URL_SCHEME`

No se admite import con esquemas de URL distintos de file y data.

`ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING`

Añadido en: v22.6.0

No se admite la eliminación de tipos para archivos descendientes de un directorio node_modules.

`ERR_UNSUPPORTED_RESOLVE_REQUEST`

Se intentó resolver un remitente de módulo no válido. Esto puede ocurrir al importar o llamar a import.meta.resolve() con:

Un especificador simple que no es un módulo incorporado desde un módulo cuyo esquema de URL no es file.
Una URL relativa desde un módulo cuyo esquema de URL no es un esquema especial.

try {
  // Intentando importar el paquete 'bare-specifier' desde un módulo de URL `data:`:
  await import('data:text/javascript,import "bare-specifier"');
} catch (e) {
  console.log(e.code); // ERR_UNSUPPORTED_RESOLVE_REQUEST
}

`ERR_USE_AFTER_CLOSE`

[Estable: 1 - Experimental]

Estable: 1 Estabilidad: 1 - Experimental

Se intentó usar algo que ya estaba cerrado.

`ERR_VALID_PERFORMANCE_ENTRY_TYPE`

Mientras se utiliza la API de temporización de rendimiento (perf_hooks), no se encuentran tipos de entrada de rendimiento válidos.

`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`

No se especificó una devolución de llamada de importación dinámica.

`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING_FLAG`

Se invocó una devolución de llamada de importación dinámica sin --experimental-vm-modules.

`ERR_VM_MODULE_ALREADY_LINKED`

El módulo que se intentó vincular no es elegible para la vinculación, debido a una de las siguientes razones:

Ya ha sido vinculado (linkingStatus es 'linked')
Está siendo vinculado (linkingStatus es 'linking')
La vinculación ha fallado para este módulo (linkingStatus es 'errored')

`ERR_VM_MODULE_CACHED_DATA_REJECTED`

La opción cachedData pasada a un constructor de módulo no es válida.

`ERR_VM_MODULE_CANNOT_CREATE_CACHED_DATA`

Los datos en caché no se pueden crear para módulos que ya han sido evaluados.

`ERR_VM_MODULE_DIFFERENT_CONTEXT`

El módulo que se devuelve de la función de enlazador es de un contexto diferente al del módulo padre. Los módulos enlazados deben compartir el mismo contexto.

`ERR_VM_MODULE_LINK_FAILURE`

El módulo no pudo vincularse debido a una falla.

`ERR_VM_MODULE_NOT_MODULE`

El valor cumplido de una promesa de vinculación no es un objeto vm.Module.

`ERR_VM_MODULE_STATUS`

El estado actual del módulo no permite esta operación. El significado específico del error depende de la función específica.

`ERR_WASI_ALREADY_STARTED`

La instancia WASI ya ha comenzado.

`ERR_WASI_NOT_STARTED`

La instancia WASI no ha comenzado.

`ERR_WEBASSEMBLY_RESPONSE`

Agregado en: v18.1.0

La Response que se ha pasado a WebAssembly.compileStreaming o a WebAssembly.instantiateStreaming no es una respuesta WebAssembly válida.

`ERR_WORKER_INIT_FAILED`

`ERR_WORKER_OUT_OF_MEMORY`

La instancia Worker terminó porque alcanzó su límite de memoria.

`ERR_WORKER_PATH`

La ruta para el script principal de un worker no es una ruta absoluta ni una ruta relativa que comience con ./ o ../.

`ERR_WORKER_UNSERIALIZABLE_ERROR`

Todos los intentos de serializar una excepción no capturada de un hilo de worker fallaron.

`ERR_WORKER_UNSUPPORTED_OPERATION`

La funcionalidad solicitada no es compatible con los hilos de worker.

`ERR_ZLIB_INITIALIZATION_FAILED`

La creación de un objeto zlib falló debido a una configuración incorrecta.

`HPE_CHUNK_EXTENSIONS_OVERFLOW`

Agregado en: v21.6.2, v20.11.1, v18.19.1

Se recibieron demasiados datos para las extensiones de un fragmento. Para protegerse contra clientes maliciosos o mal configurados, si se reciben más de 16 KiB de datos, se emitirá un Error con este código.

`HPE_HEADER_OVERFLOW`

[Historia]

Versión	Cambios
v11.4.0, v10.15.0	El tamaño máximo de la cabecera en `http_parser` se estableció en 8 KiB.

Se recibieron demasiados datos de la cabecera HTTP. Para protegerse contra clientes maliciosos o mal configurados, si se reciben más de maxHeaderSize datos de cabecera HTTP, el análisis HTTP se abortará sin que se cree un objeto de solicitud o respuesta, y se emitirá un Error con este código.

`HPE_UNEXPECTED_CONTENT_LENGTH`

El servidor está enviando tanto una cabecera Content-Length como Transfer-Encoding: chunked.

Transfer-Encoding: chunked permite al servidor mantener una conexión persistente HTTP para contenido generado dinámicamente. En este caso, no se puede utilizar la cabecera HTTP Content-Length.

Utilice Content-Length o Transfer-Encoding: chunked.

`MODULE_NOT_FOUND`

[Historia]

Versión	Cambios
v12.0.0	Se añadió la propiedad `requireStack`.

Un archivo de módulo no pudo ser resuelto por el cargador de módulos CommonJS al intentar una operación require() o al cargar el punto de entrada del programa.

Códigos de error heredados de Node.js

[Estable: 0 - Obsoleto]

Estable: 0 Estabilidad: 0 - Obsoleto. Estos códigos de error son inconsistentes o han sido eliminados.

`ERR_CANNOT_TRANSFER_OBJECT`

Añadido en: v10.5.0

Eliminado en: v12.5.0

El valor pasado a postMessage() contenía un objeto que no es compatible para la transferencia.

`ERR_CPU_USAGE`

Eliminado en: v15.0.0

La llamada nativa desde process.cpuUsage no pudo ser procesada.

`ERR_CRYPTO_HASH_DIGEST_NO_UTF16`

Añadido en: v9.0.0

Eliminado en: v12.12.0

La codificación UTF-16 se utilizó con hash.digest(). Si bien el método hash.digest() permite que se pase un argumento encoding, lo que hace que el método devuelva una cadena en lugar de un Buffer, la codificación UTF-16 (por ejemplo, ucs o utf16le) no es compatible.

`ERR_CRYPTO_SCRYPT_INVALID_PARAMETER`

Eliminado en: v23.0.0

Se pasó una combinación incompatible de opciones a crypto.scrypt() o crypto.scryptSync(). Las nuevas versiones de Node.js usan el código de error ERR_INCOMPATIBLE_OPTION_PAIR en su lugar, que es consistente con otras APIs.

Este código de error fue reemplazado por ERR_MISSING_TRANSFERABLE_IN_TRANSFER_LIST en Node.js v15.0.0, porque ya no es preciso ya que ahora también existen otros tipos de objetos transferibles.

`ERR_MISSING_TRANSFERABLE_IN_TRANSFER_LIST`

[Historial]

Versión	Cambios
v21.0.0	Se lanza una `DOMException` en su lugar.
v21.0.0	Eliminado en: v21.0.0
v15.0.0	Agregado en: v15.0.0

Un objeto que necesita estar listado explícitamente en el argumento transferList está en el objeto pasado a una llamada de postMessage(), pero no se proporciona en el transferList para esa llamada. Por lo general, esto es un MessagePort.

En las versiones de Node.js anteriores a v15.0.0, el código de error que se utilizaba aquí era ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST. Sin embargo, el conjunto de tipos de objetos transferibles se ha ampliado para cubrir más tipos que MessagePort.

`ERR_NAPI_CONS_PROTOTYPE_OBJECT`

Agregado en: v9.0.0

Eliminado en: v10.0.0

Utilizado por la Node-API cuando Constructor.prototype no es un objeto.

`ERR_NAPI_TSFN_START_IDLE_LOOP`

Agregado en: v10.6.0, v8.16.0

Eliminado en: v14.2.0, v12.17.0

En el hilo principal, los valores se eliminan de la cola asociada con la función segura para subprocesos en un bucle inactivo. Este error indica que se ha producido un error al intentar iniciar el bucle.

`ERR_NAPI_TSFN_STOP_IDLE_LOOP`

Agregado en: v10.6.0, v8.16.0

Eliminado en: v14.2.0, v12.17.0

Una vez que no quedan más elementos en la cola, el bucle inactivo debe suspenderse. Este error indica que el bucle inactivo no se ha detenido.

`ERR_NO_LONGER_SUPPORTED`

Se encontró un SharedArrayBuffer cuya memoria no está gestionada por el motor de JavaScript o por Node.js durante la serialización. Tal SharedArrayBuffer no se puede serializar.

Esto solo puede suceder cuando los complementos nativos crean SharedArrayBuffers en modo "externalizado", o ponen SharedArrayBuffer existentes en modo externalizado.

`ERR_UNKNOWN_STDIN_TYPE`

Añadido en: v8.0.0

Eliminado en: v11.7.0

Se intentó iniciar un proceso de Node.js con un tipo de archivo stdin desconocido. Este error suele ser una indicación de un error dentro de Node.js, aunque es posible que el código de usuario lo desencadene.

`ERR_UNKNOWN_STREAM_TYPE`

Añadido en: v8.0.0

Eliminado en: v11.7.0

Se intentó iniciar un proceso de Node.js con un tipo de archivo stdout o stderr desconocido. Este error suele ser una indicación de un error dentro de Node.js, aunque es posible que el código de usuario lo desencadene.

`ERR_V8BREAKITERATOR`

Se utilizó la API BreakIterator de V8, pero no está instalado el conjunto de datos ICU completo.

`ERR_VALUE_OUT_OF_RANGE`

Añadido en: v9.0.0

Eliminado en: v10.0.0

Se usa cuando un valor dado está fuera del rango aceptado.

`ERR_VM_MODULE_LINKING_ERRORED`

Añadido en: v10.0.0

Eliminado en: v18.1.0, v16.17.0

La función del enlazador devolvió un módulo para el cual ha fallado el enlace.

`ERR_VM_MODULE_NOT_LINKED`

El módulo debe enlazarse correctamente antes de la instanciación.

`ERR_WORKER_UNSUPPORTED_EXTENSION`

Añadido en: v11.0.0

Eliminado en: v16.9.0

El nombre de ruta utilizado para el script principal de un worker tiene una extensión de archivo desconocida.

`ERR_ZLIB_BINDING_CLOSED`

Añadido en: v9.0.0

Eliminado en: v10.0.0

Se usa cuando se intenta utilizar un objeto zlib después de que ya se haya cerrado.

Códigos de Error de OpenSSL

Errores de Validez Temporal

`CERT_NOT_YET_VALID`

El certificado aún no es válido: la fecha notBefore es posterior a la hora actual.

`CERT_HAS_EXPIRED`

El certificado ha expirado: la fecha notAfter es anterior a la hora actual.

`CRL_NOT_YET_VALID`

La lista de revocación de certificados (CRL) tiene una fecha de emisión futura.

`CRL_HAS_EXPIRED`

La lista de revocación de certificados (CRL) ha expirado.

`CERT_REVOKED`

El certificado ha sido revocado; está en una lista de revocación de certificados (CRL).

`UNABLE_TO_GET_ISSUER_CERT`

No se pudo encontrar el certificado emisor de un certificado buscado. Normalmente, esto significa que la lista de certificados de confianza no está completa.

`UNABLE_TO_GET_ISSUER_CERT_LOCALLY`

Se desconoce el emisor del certificado. Este es el caso si el emisor no está incluido en la lista de certificados de confianza.

`DEPTH_ZERO_SELF_SIGNED_CERT`

El certificado pasado está autofirmado y no se puede encontrar el mismo certificado en la lista de certificados de confianza.

`SELF_SIGNED_CERT_IN_CHAIN`

Se desconoce el emisor del certificado. Este es el caso si el emisor no está incluido en la lista de certificados de confianza.

`CERT_CHAIN_TOO_LONG`

La longitud de la cadena de certificados es mayor que la profundidad máxima.

`UNABLE_TO_GET_CRL`

No se pudo encontrar la CRL referenciada por el certificado.

`UNABLE_TO_VERIFY_LEAF_SIGNATURE`

No se pudo verificar ninguna firma porque la cadena contiene solo un certificado y no está autofirmado.

`CERT_UNTRUSTED`

La autoridad de certificación (CA) raíz no está marcada como de confianza para el propósito especificado.

Errores Básicos de Extensión

`INVALID_CA`

Un certificado de CA no es válido. O no es una CA o sus extensiones no son coherentes con el propósito suministrado.

`PATH_LENGTH_EXCEEDED`

Se ha excedido el parámetro pathlength de basicConstraints.

`HOSTNAME_MISMATCH`

El certificado no coincide con el nombre proporcionado.

Errores de Uso y Política

`INVALID_PURPOSE`

El certificado suministrado no se puede utilizar para el propósito especificado.

`CERT_REJECTED`

La CA raíz está marcada para rechazar el propósito especificado.

Errores de Formato

`CERT_SIGNATURE_FAILURE`

La firma del certificado no es válida.

`CRL_SIGNATURE_FAILURE`

La firma de la lista de revocación de certificados (CRL) no es válida.

`ERROR_IN_CERT_NOT_BEFORE_FIELD`

El campo notBefore del certificado contiene una hora no válida.

`ERROR_IN_CERT_NOT_AFTER_FIELD`

El campo notAfter del certificado contiene una hora no válida.

`ERROR_IN_CRL_LAST_UPDATE_FIELD`

El campo lastUpdate de la CRL contiene una hora no válida.

`ERROR_IN_CRL_NEXT_UPDATE_FIELD`

El campo nextUpdate de la CRL contiene una hora no válida.

`UNABLE_TO_DECRYPT_CERT_SIGNATURE`

No se pudo descifrar la firma del certificado. Esto significa que no se pudo determinar el valor real de la firma en lugar de que no coincida con el valor esperado, esto solo es significativo para las claves RSA.

`UNABLE_TO_DECRYPT_CRL_SIGNATURE`

No se pudo descifrar la firma de la lista de revocación de certificados (CRL): esto significa que no se pudo determinar el valor real de la firma en lugar de que no coincida con el valor esperado.

`UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY`

No se pudo leer la clave pública en el SubjectPublicKeyInfo del certificado.

Otros errores de OpenSSL

`OUT_OF_MEM`

Se produjo un error al intentar asignar memoria. Esto nunca debería suceder.

Errores ​

Propagación e interceptación de errores ​

Clase: Error ​

new Error(message[, options]) ​

Error.captureStackTrace(targetObject[, constructorOpt]) ​

Error.stackTraceLimit ​

error.cause ​

error.code ​

error.message ​

error.stack ​

Clase: AssertionError ​

Clase: RangeError ​

Clase: ReferenceError ​

Clase: SyntaxError ​

Clase: SystemError ​

error.address ​

error.code ​

error.dest ​

error.errno ​

error.info ​

error.message ​

error.path ​

error.port ​

error.syscall ​

Errores comunes del sistema ​

Clase: TypeError ​

Excepciones vs. errores ​

Errores de OpenSSL ​

error.opensslErrorStack ​

error.function ​

error.library ​

error.reason ​

Códigos de error de Node.js ​

ABORT_ERR ​

ERR_ACCESS_DENIED ​

ERR_AMBIGUOUS_ARGUMENT ​

ERR_ARG_NOT_ITERABLE ​

ERR_ASSERTION ​

ERR_ASYNC_CALLBACK ​

ERR_ASYNC_TYPE ​

ERR_BROTLI_COMPRESSION_FAILED ​

ERR_BROTLI_INVALID_PARAM ​

ERR_BUFFER_CONTEXT_NOT_AVAILABLE ​

ERR_BUFFER_OUT_OF_BOUNDS ​

ERR_BUFFER_TOO_LARGE ​

ERR_CANNOT_WATCH_SIGINT ​

ERR_CHILD_CLOSED_BEFORE_REPLY ​

ERR_CHILD_PROCESS_IPC_REQUIRED ​

ERR_CHILD_PROCESS_STDIO_MAXBUFFER ​

ERR_CLOSED_MESSAGE_PORT ​

ERR_CONSOLE_WRITABLE_STREAM ​

ERR_CONSTRUCT_CALL_INVALID ​

ERR_CONSTRUCT_CALL_REQUIRED ​

ERR_CONTEXT_NOT_INITIALIZED ​

ERR_CRYPTO_CUSTOM_ENGINE_NOT_SUPPORTED ​

ERR_CRYPTO_ECDH_INVALID_FORMAT ​

ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY ​

ERR_CRYPTO_ENGINE_UNKNOWN ​

ERR_CRYPTO_FIPS_FORCED ​

ERR_CRYPTO_FIPS_UNAVAILABLE ​

ERR_CRYPTO_HASH_FINALIZED ​

ERR_CRYPTO_HASH_UPDATE_FAILED ​

ERR_CRYPTO_INCOMPATIBLE_KEY ​

ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS ​

ERR_CRYPTO_INITIALIZATION_FAILED ​

ERR_CRYPTO_INVALID_AUTH_TAG ​

ERR_CRYPTO_INVALID_COUNTER ​

ERR_CRYPTO_INVALID_CURVE ​

ERR_CRYPTO_INVALID_DIGEST ​

ERR_CRYPTO_INVALID_IV ​

ERR_CRYPTO_INVALID_JWK ​

ERR_CRYPTO_INVALID_KEYLEN ​

ERR_CRYPTO_INVALID_KEYPAIR ​

ERR_CRYPTO_INVALID_KEYTYPE ​

ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE ​

ERR_CRYPTO_INVALID_MESSAGELEN ​

ERR_CRYPTO_INVALID_SCRYPT_PARAMS ​

ERR_CRYPTO_INVALID_STATE ​

ERR_CRYPTO_INVALID_TAG_LENGTH ​

ERR_CRYPTO_JOB_INIT_FAILED ​

Errores

Propagación e interceptación de errores

Clase: `Error`

`new Error(message[, options])`

`Error.captureStackTrace(targetObject[, constructorOpt])`

`Error.stackTraceLimit`

`error.cause`

`error.code`

`error.message`

`error.stack`

Clase: `AssertionError`

Clase: `RangeError`

Clase: `ReferenceError`

Clase: `SyntaxError`

Clase: `SystemError`

`error.address`

`error.code`

`error.dest`

`error.errno`

`error.info`

`error.message`

`error.path`

`error.port`

`error.syscall`

Errores comunes del sistema

Clase: `TypeError`

Excepciones vs. errores

Errores de OpenSSL

`error.opensslErrorStack`

`error.function`

`error.library`

`error.reason`

Códigos de error de Node.js

`ABORT_ERR`

`ERR_ACCESS_DENIED`

`ERR_AMBIGUOUS_ARGUMENT`

`ERR_ARG_NOT_ITERABLE`

`ERR_ASSERTION`

`ERR_ASYNC_CALLBACK`

`ERR_ASYNC_TYPE`

`ERR_BROTLI_COMPRESSION_FAILED`

`ERR_BROTLI_INVALID_PARAM`

`ERR_BUFFER_CONTEXT_NOT_AVAILABLE`

`ERR_BUFFER_OUT_OF_BOUNDS`

`ERR_BUFFER_TOO_LARGE`

`ERR_CANNOT_WATCH_SIGINT`

`ERR_CHILD_CLOSED_BEFORE_REPLY`

`ERR_CHILD_PROCESS_IPC_REQUIRED`

`ERR_CHILD_PROCESS_STDIO_MAXBUFFER`

`ERR_CLOSED_MESSAGE_PORT`

`ERR_CONSOLE_WRITABLE_STREAM`

`ERR_CONSTRUCT_CALL_INVALID`

`ERR_CONSTRUCT_CALL_REQUIRED`

`ERR_CONTEXT_NOT_INITIALIZED`

`ERR_CRYPTO_CUSTOM_ENGINE_NOT_SUPPORTED`

`ERR_CRYPTO_ECDH_INVALID_FORMAT`

`ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY`

`ERR_CRYPTO_ENGINE_UNKNOWN`

`ERR_CRYPTO_FIPS_FORCED`

`ERR_CRYPTO_FIPS_UNAVAILABLE`

`ERR_CRYPTO_HASH_FINALIZED`

`ERR_CRYPTO_HASH_UPDATE_FAILED`

`ERR_CRYPTO_INCOMPATIBLE_KEY`

`ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS`

`ERR_CRYPTO_INITIALIZATION_FAILED`

`ERR_CRYPTO_INVALID_AUTH_TAG`

`ERR_CRYPTO_INVALID_COUNTER`

`ERR_CRYPTO_INVALID_CURVE`

`ERR_CRYPTO_INVALID_DIGEST`

`ERR_CRYPTO_INVALID_IV`

`ERR_CRYPTO_INVALID_JWK`

`ERR_CRYPTO_INVALID_KEYLEN`

`ERR_CRYPTO_INVALID_KEYPAIR`

`ERR_CRYPTO_INVALID_KEYTYPE`

`ERR_CRYPTO_INVALID_KEY_OBJECT_TYPE`

`ERR_CRYPTO_INVALID_MESSAGELEN`

`ERR_CRYPTO_INVALID_SCRYPT_PARAMS`

`ERR_CRYPTO_INVALID_STATE`

`ERR_CRYPTO_INVALID_TAG_LENGTH`

`ERR_CRYPTO_JOB_INIT_FAILED`