Errores

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

Errores estándar de JavaScript como <EvalError>, <SyntaxError>, <RangeError>, <ReferenceError>, <TypeError> y <URIError>.
Errores del sistema desencadenados por restricciones 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 desencadenados por el código de la aplicación.
AssertionErrors son una clase especial de error que se puede desencadenar cuando Node.js detecta una violación lógica excepcional que nunca debería ocurrir. Estos son generados típicamente por el módulo node:assert.

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

Propagación e intercepció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 lanzan 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 un ReferenceError porque z no está definida.
try {
  const m = 1
  const n = m + z
} catch (err) {
  // Manejar el error aquí.
}

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

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

Los errores que se producen dentro de las API Asíncronas pueden informarse de varias maneras:

Algunos métodos asíncronos devuelven una <Promise>, siempre debe tener en cuenta que podría ser rechazada. Consulte la bandera --unhandled-rejections para ver cómo reaccionará el proceso ante 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 se produjo un error que debe manejarse.
Cuando se llama a un método asíncrono en un objeto que es un EventEmitter, los errores pueden dirigirse al evento 'error' de ese objeto.
Un puñado de métodos típicamente asíncronos en la API de Node.js aún pueden usar el mecanismo throw para generar excepciones que deben ser manejadas usando try…catch. No existe una lista exhaustiva de tales métodos; consulte la documentación de cada método para determinar el mecanismo de manejo de errores apropiado que se requiere.

El uso del mecanismo de evento 'error' es más común para las API basadas en flujos y basadas en emisores de eventos, que a su vez representan una serie de operaciones asíncronas a lo largo del tiempo (a diferencia de 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 se lanzará, lo que hará que el proceso de Node.js informe de una excepción no detectada y se bloquee a menos que: se haya registrado un controlador para el evento 'uncaughtException', o se utilice el módulo node:domain obsoleto.

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 que llama 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 "seguimiento de pila" que detalla el punto en el código en el que se instanció Error, y puede 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 en el 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 seguimientos de pila dependen de la API de seguimiento de pila de V8. Los seguimientos de pila se extienden solo hasta (a) el comienzo de la ejecución de código síncrono, o (b) el número de marcos dado por la propiedad Error.stackTraceLimit, el que sea menor.

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

targetObject <Objeto>
constructorOpt <Función>

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

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

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

El argumento opcional constructorOpt acepta una función. Si se proporciona, todos los marcos 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() {
  // Crea un error sin rastreo de pila para evitar calcular el rastreo de pila dos veces.
  const { stackTraceLimit } = Error
  Error.stackTraceLimit = 0
  const error = new Error()
  Error.stackTraceLimit = stackTraceLimit

  // Captura el rastreo de pila por encima de la función b
  Error.captureStackTrace(error, b) // Ni la función c ni la b se incluyen en el rastreo de pila
  throw error
}

a()

`Error.stackTraceLimit`

<número>

La propiedad Error.stackTraceLimit especifica el número de marcos de pila recopilados por un rastreo 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 de JavaScript válido. Los cambios afectarán a cualquier rastreo 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 en un número negativo, los rastreos de pila no capturarán ningún marco.

`error.cause`

Agregado en: v16.9.0

<cualquiera>

Si está presente, la propiedad error.cause es la causa subyacente del Error. Se utiliza cuando se detecta un error y se lanza 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 la establece 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á establecido.

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

console.log(symptom)
// Imprime:
//   Error: El mensaje no se pudo enviar
//       at REPL2:1:17
//       at Script.runInThisContext (node:vm:130:12)
//       ... 7 líneas que coinciden con el rastreo de pila de 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 de error.message pueden cambiar entre cualquier versión de Node.js. Consulta 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 establecida al llamar a new Error(message). El message pasado al constructor también aparecerá en la primera línea del rastreo de pila del Error, sin embargo, cambiar esta propiedad después de que se crea el objeto Error puede que no cambie la primera línea del rastreo de 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 va seguida de una serie de marcos de pila (cada línea comienza con "at "). Cada marco describe un sitio de llamada dentro del código que llevó 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 la función determinado se mostrará con información de ubicación agregada 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 de C++ llamada cheetahify que a su vez llama a una función de JavaScript, el marco que representa la llamada a cheetahify no estará presente en los rastreos de pila:

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

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

makeFaster()
// arrojará:
//   /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).
nombre-de-archivo-simple.js:línea:columna, si el marco representa una llamada interna a Node.js.
/ruta/absoluta/al/archivo.js:línea:columna, si el marco representa una llamada en un programa de usuario (utilizando el sistema de módulos CommonJS) o sus dependencias.
\<protocolo-de-transporte\>:///url/al/módulo/archivo.mjs:línea:columna, 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 seguimiento de la pila se genera de forma diferida cuando se accede a la propiedad error.stack.

El número de marcos capturados por el seguimiento de pila está limitado por el menor de Error.stackTraceLimit o el número de marcos disponibles en el ciclo de eventos actual.

Clase: `AssertionError`

Extiende: <errors.Error>

Indica el fallo de una aserción. Para obtener más detalles, consulta Clase: 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: la opción "port" debe ser >= 0 y < 65536: -1"

Node.js generará y lanzará instancias 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. Estos errores suelen indicar 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 genere y ejecute 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 se producen excepciones dentro de su entorno de ejecución. Estos suelen ocurrir cuando una aplicación viola una restricción del sistema operativo. Por ejemplo, se producirá 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 desencadenó 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 cuando se informa de 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 libuv Error handling.

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

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

`error.info`

<Objeto>

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 legible por humanos proporcionada por el sistema sobre el error.

`error.path`

<string>

Si está presente, error.path es una cadena que contiene una ruta de acceso inválida 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 syscall 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 de 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 vincular un servidor (net, http o https) a una dirección local falló debido a que otro servidor en el sistema local ya ocupa esa dirección.
ECONNREFUSED (Conexión rechazada): No se pudo establecer 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 extranjero.
ECONNRESET (Conexión restablecida por el par): Un par cerró forzosamente una conexión. 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 fue 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 archivo 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 Node.js.
ENOENT (No existe tal archivo o directorio): Comúnmente generado por las operaciones 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 fue el objetivo de una operación que requiere un directorio vacío, generalmente fs.unlink.
ENOTFOUND (Error de búsqueda de DNS): Indica un fallo de DNS de EAI_NODATA o EAI_NONAME. Este no es un error estándar de POSIX.
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 secuencia en la que se está escribiendo se ha cerrado.
ETIMEDOUT (Tiempo de espera de la operación agotado): 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 se encuentra en http o net. A menudo es una señal de que no se llamó correctamente a socket.end().

Clase: `TypeError`

Extiende a <errors.Error>

Indica que un argumento proporcionado no es de 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 instrucción throw. Si bien no es necesario 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 se bloquee. Los ejemplos incluyen las comprobaciones assert() o las llamadas abort() en la capa C++.

Errores de OpenSSL

Los errores que se originan en crypto o tls son de la 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 sobre 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 la razón del error.

Códigos de error de Node.js

`ABORT_ERR`

Añadido en: v15.0.0

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

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

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

`ERR_ACCESS_DENIED`

Un tipo especial de error que se activa cuando 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 estar mal entendida. El módulo node:assert lanza este error 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 un error.

`ERR_ARG_NOT_ITERABLE`

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

`ERR_ASSERTION`

Un tipo especial de error que se puede desencadenar cuando Node.js detecta una violación lógica excepcional que nunca debería ocurrir. Estos errores son generados 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 de incrustación pública.

`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 Buffer de Node.js desde un complemento o código de incrustación, mientras se encontraba en un Contexto de motor JS que no está asociado con una instancia de Node.js. Los datos pasados al método Buffer habrán sido liberados en el momento en que el método regrese.

Cuando se encuentre con 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 generalmente se aceptan en todas las API principales de Node.js donde se usan 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 intentó crear un Buffer más grande que el tamaño máximo permitido.

`ERR_CANNOT_WATCH_SIGINT`

Node.js no pudo observar 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 se crea un proceso hijo 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`

[Historial]

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

Se intentó usar una instancia de MessagePort en un estado cerrado, generalmente después de que se haya llamado a .close().

`ERR_CONSOLE_WRITABLE_STREAM`

Se instanció Console sin un flujo stdout, o Console tiene un flujo stdout o stderr que no es de escritura.

`ERR_CONSTRUCT_CALL_INVALID`

Añadido en: v12.5.0

Se llamó a un constructor de clase que no se puede llamar.

`ERR_CONSTRUCT_CALL_REQUIRED`

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

`ERR_CONTEXT_NOT_INITIALIZED`

El contexto vm pasado a la API aún no está inicializado. Esto podría suceder cuando ocurre un error (y se captura) 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(). Esto significa que la clave pública está 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 utilizó 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`

Se llamó a hash.digest() 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 debería suceder, si es que sucede alguna vez.

`ERR_CRYPTO_INCOMPATIBLE_KEY`

Las claves criptográficas proporcionadas 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`

Añadido en: v15.0.0

La inicialización del subsistema criptográfico falló.

`ERR_CRYPTO_INVALID_AUTH_TAG`

Añadido en: v15.0.0

Se proporcionó una etiqueta de autenticación inválida.

`ERR_CRYPTO_INVALID_COUNTER`

Añadido en: v15.0.0

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

`ERR_CRYPTO_INVALID_CURVE`

Añadido en: v15.0.0

Se proporcionó una curva elíptica invá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 fue compilado sin soporte para scrypt. No es posible con los binarios de la versión oficial, pero puede ocurrir con compilaciones personalizadas, incluidas las compilaciones de distribuciones.

`ERR_CRYPTO_SIGN_KEY_REQUIRED`

No se proporcionó una key 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 compatible.

`ERR_DEBUGGER_ERROR`

Agregado en: v16.4.0, v14.17.4

Ocurrió 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ó realizar una lectura o cierre síncrono en un fs.Dir que tiene operaciones asíncronas en curso.

`ERR_DLOPEN_DISABLED`

Agregado en: v16.10.0, v14.19.0

La carga de complementos nativos se ha deshabilitado usando --no-addons.

`ERR_DLOPEN_FAILED`

Agregado en: v15.0.0

Una llamada a process.dlopen() falló.

`ERR_DNS_SET_SERVERS_FAILED`

c-ares no pudo establecer el servidor DNS.

`ERR_DOMAIN_CALLBACK_NOT_AVAILABLE`

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

`ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE`

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

El rastreo de pila se extiende para incluir el momento en que se había cargado el módulo node:domain.

`ERR_DUPLICATE_STARTUP_SNAPSHOT_MAIN_FUNCTION`

v8.startupSnapshot.setDeserializeMainFunction() no se pudo llamar 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 compatibles con WHATWG.

`ERR_EVAL_ESM_CANNOT_PRINT`

--print no se puede usar con entradas ESM.

`ERR_EVENT_RECURSION`

Se produce cuando se intenta enviar un evento de forma recursiva 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 usa como una biblioteca integrada y algunos hooks para el motor de JS no están configurados correctamente.

`ERR_FALSY_VALUE_REJECTION`

Una Promise que se convirtió en callback mediante util.callbackify() fue rechazada con un valor falso.

`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 solicitudes HTTP/2 que usan el método CONNECT, se requiere el pseudo-encabezado :authority.

`ERR_HTTP2_CONNECT_PATH`

Para solicitudes HTTP/2 que usan el método CONNECT, el pseudo-encabezado :path está prohibido.

`ERR_HTTP2_CONNECT_SCHEME`

Para solicitudes HTTP/2 que usan el método CONNECT, el pseudo-encabezado :scheme está prohibido.

`ERR_HTTP2_ERROR`

Ha ocurrido un error HTTP/2 no específico.

`ERR_HTTP2_GOAWAY_SESSION`

No se pueden abrir nuevos flujos HTTP/2 después de que 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 múltiples valores para un campo de encabezado HTTP/2 que debía tener un solo 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`

Está prohibido el uso de encabezados específicos de la conexión HTTP/1 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 (incluidos).

`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 un múltiplo de seis.

`ERR_HTTP2_INVALID_PSEUDOHEADER`

Solo se pueden usar pseudocabeceras HTTP/2 válidas (: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 de 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`

Siempre que se envía un marco SETTINGS de HTTP/2 a un par conectado, se requiere que el par envíe un reconocimiento de que ha recibido y aplicado la nueva SETTINGS. De forma predeterminada, 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`

Falta de 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 una 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 una carga útil está prohibida.

`ERR_HTTP2_PING_CANCEL`

Se canceló un ping de HTTP/2.

`ERR_HTTP2_PING_LENGTH`

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

`ERR_HTTP2_PSEUDOHEADER_NOT_ALLOWED`

Se ha utilizado un pseudo-encabezado HTTP/2 de manera inapropiada. Los pseudo-encabezados son nombres de claves 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ó usar la API Http2Stream.prototype.responseWithFile() para enviar un directorio.

`ERR_HTTP2_SEND_FILE_NOSEEK`

Se intentó usar la API Http2Stream.prototype.responseWithFile() para enviar algo que no era 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 se canceló.

`ERR_HTTP2_SOCKET_BOUND`

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

`ERR_HTTP2_SOCKET_UNBOUND`

Se intentó usar la propiedad socket de una Http2Session que ya se había cerrado.

`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 par conectado.

`ERR_HTTP2_STREAM_ERROR`

Se ha especificado un código de error distinto de cero en un marco 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 principal. 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 superado el número de configuraciones personalizadas admitidas (10).

`ERR_HTTP2_TOO_MANY_INVALID_FRAMES`

Añadido en: v15.14.0

Se ha superado el límite de marcos de protocolo HTTP/2 no válidos aceptables enviados por el par, tal como se especifica a través de 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 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`

A http2.connect() se le pasó una URL que usa 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 los encabezados ya se habían enviado.

`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`

El ServerResponse dado ya tenía un socket asignado.

`ERR_HTTP_SOCKET_ENCODING`

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

`ERR_HTTP_TRAILER_INVALID`

Se estableció el encabezado Trailer a pesar de que la codificación de transferencia no lo admite.

`ERR_ILLEGAL_CONSTRUCTOR`

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

`ERR_IMPORT_ATTRIBUTE_MISSING`

Agregado 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`

Agregado 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`

Agregado 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

La bandera --input-type se utilizó 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`

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

`ERR_INSPECTOR_ALREADY_CONNECTED`

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

`ERR_INSPECTOR_CLOSED`

Al usar el módulo node:inspector, se intentó usar el inspector después de que la sesión ya se había cerrado.

`ERR_INSPECTOR_COMMAND`

Ocurrió 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 usaba el módulo node:inspector, se intentó usar el inspector antes de que se conectara.

`ERR_INSPECTOR_NOT_WORKER`

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

`ERR_INTERNAL_ASSERTION`

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

`ERR_INVALID_ADDRESS`

La dirección proporcionada no es entendida por la API de Node.js.

`ERR_INVALID_ADDRESS_FAMILY`

La familia de direcciones proporcionada no es entendida por la API de Node.js.

`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 compatible para un argumento dado.

`ERR_INVALID_ASYNC_ID`

Se pasó un asyncId o triggerAsyncId no válido usando AsyncHooks. Una 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`

Un cursor en un flujo dado no se puede mover a una fila específica sin una columna especificada.

`ERR_INVALID_FD`

Un descriptor de archivo ('fd') no era válido (p. ej., tenía 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 por otros motivos.

`ERR_INVALID_MODULE_SPECIFIER`

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

`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 falló al analizarse.

`ERR_INVALID_PACKAGE_TARGET`

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

`ERR_INVALID_PROTOCOL`

Se pasó un options.protocol invá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 está soportado.

`ERR_INVALID_REPL_INPUT`

La entrada no se puede utilizar en el REPL. Las condiciones bajo las cuales se utiliza este error se describen en la documentación del 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 sus 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`

Añadido en: v15.0.0

Indica que una operación no se puede completar debido a un estado inválido. Por ejemplo, un objeto ya 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 un fork asíncrono. Consulte la documentación del módulo child_process para obtener más información.

`ERR_INVALID_THIS`

Se llamó a una función 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 WHATWG constructor URLSearchParams 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`

Añadido en: v23.0.0

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

`ERR_INVALID_URI`

Se pasó un URI no válido.

`ERR_INVALID_URL`

Se pasó una URL no válida al constructor URL de WHATWG o al método url.parse() heredado para su análisis. El objeto de error lanzado suele tener una propiedad adicional 'input' que contiene la URL que no se pudo analizar.

`ERR_INVALID_URL_SCHEME`

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

`ERR_IPC_CHANNEL_CLOSED`

Se intentó utilizar 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. Consulta la documentación del módulo child_process para obtener más información.

`ERR_IPC_ONE_PIPE`

Se intentó crear un proceso hijo de Node.js utilizando más de un canal de comunicación IPC. Consulta 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. Consulta la documentación del módulo child_process para obtener más información.

`ERR_IP_BLOCKED`

La IP está bloqueada por net.BlockList.

`ERR_LOADER_CHAIN_INCOMPLETE`

Agregado en: v18.6.0, v16.17.0

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

`ERR_LOAD_SQLITE_EXTENSION`

Añadido en: v23.5.0

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

`ERR_MEMORY_ALLOCATION_FAILED`

Se intentó asignar memoria (normalmente en la capa de C++) pero falló.

`ERR_MESSAGE_TARGET_CONTEXT_UNAVAILABLE`

Añadido en: v14.5.0, v12.19.0

No se pudo deserializar un mensaje enviado a un MessagePort en el Context de vm de destino. No todos los objetos de Node.js pueden ser instanciados con éxito 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 está implementado.

`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 en su lugar se puede usar el código de error ERR_INVALID_ARG_TYPE.

`ERR_MISSING_OPTION`

Para APIs que aceptan objetos de opciones, algunas opciones pueden 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 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 integrador para Workers. En particular, este error no ocurrirá con las compilaciones estándar de Node.js.

`ERR_MODULE_NOT_FOUND`

El cargador de módulos ECMAScript no pudo resolver un archivo de módulo al intentar una operación import o al cargar el punto de entrada del programa.

`ERR_MULTIPLE_CALLBACK`

Se llamó a una función de devolución de llamada más de una vez.

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

`ERR_NAPI_CONS_FUNCTION`

Mientras se utilizaba 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 * tamaño_de_elemento) + byte_offset era mayor que la longitud del buffer dado.

`ERR_NAPI_TSFN_CALL_JS`

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

`ERR_NAPI_TSFN_GET_UNDEFINED`

Se produjo un error al intentar recuperar el valor undefined de JavaScript.

`ERR_NON_CONTEXT_AWARE_DISABLED`

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

`ERR_NOT_BUILDING_SNAPSHOT`

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

`ERR_NOT_IN_SINGLE_EXECUTABLE_APPLICATION`

Añadido 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 de OpenSSL.

`ERR_NO_ICU`

Se intentó utilizar funciones que requieren ICU, pero Node.js no se compiló con soporte de ICU.

`ERR_NO_TYPESCRIPT`

Añadido en: v23.0.0

Se intentó utilizar funciones que requieren soporte nativo de TypeScript, pero Node.js no se compiló con soporte de TypeScript.

`ERR_OPERATION_FAILED`

Añadido en: v15.0.0

Una operación falló. Esto se utiliza 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 de paquetes, a menos que se utilice una URL absoluta.

`ERR_PARSE_ARGS_INVALID_OPTION_VALUE`

Agregado en: v18.3.0, v16.17.0

Cuando strict se establece en true, lanzado por util.parseArgs() 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`

Añadido en: v18.3.0, v16.17.0

Lanzado por util.parseArgs(), cuando se proporciona un argumento posicional y allowPositionals está establecido en false.

`ERR_PARSE_ARGS_UNKNOWN_OPTION`

Añadido en: v18.3.0, v16.17.0

Cuando strict está establecido en true, lanzado por util.parseArgs() 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 CommonJS a ESM o ESM a CommonJS participa en un ciclo inmediato. Esto no está permitido porque los módulos ES no pueden ser evaluados mientras ya están siendo evaluados.

Para evitar el ciclo, la llamada 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 hacerse de forma diferida en una función interna.

`ERR_REQUIRE_ESM`

[Historial]

Versión	Cambios
v23.0.0	require() ahora soporta la carga de módulos ES síncronos por defecto.

[Estable: 0 - Obsoleto]

Estable: 0 Estabilidad: 0 - Obsoleto

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

Este error ha quedado obsoleto ya que require() ahora soporta 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`

El método server.listen() fue llamado mientras que un net.Server ya estaba escuchando. Esto aplica a todas las instancias de net.Server, incluyendo instancias de Server HTTP, HTTPS y HTTP/2.

`ERR_SERVER_NOT_RUNNING`

El método server.close() fue llamado cuando un net.Server no se estaba ejecutando. Esto aplica a todas las instancias de net.Server, incluyendo instancias de Server 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 API 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 no vá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 no válido.

`ERR_SOCKET_BAD_TYPE`

Una función API que esperaba un tipo de socket (udp4 o udp6) recibió un valor no vá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 que ya estaba cerrado.

`ERR_SOCKET_CLOSED_BEFORE_CONNECTION`

Al llamar a net.Socket.write() en un socket que se está conectando, el socket se cerró antes de que se estableciera 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 a dgram.connect() en un socket ya conectado.

`ERR_SOCKET_DGRAM_NOT_CONNECTED`

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

`ERR_SOCKET_DGRAM_NOT_RUNNING`

Se realizó una llamada y el subsistema UDP no estaba en ejecución.

`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 de un mapa de origen.

`ERR_SQLITE_ERROR`

Agregado 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. Verifique 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 un flujo Writable.

`ERR_STREAM_DESTROYED`

Se llamó a un método de flujo que no puede completarse porque el flujo fue destruido 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 un flujo o una tubería termina de manera no elegante 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) al flujo.

`ERR_STREAM_UNABLE_TO_PIPE`

Se intentó canalizar a un flujo cerrado o destruido en una tubería.

`ERR_STREAM_UNSHIFT_AFTER_END_EVENT`

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

`ERR_STREAM_WRAP`

Impide 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 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 de 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. Se puede encontrar información adicional sobre el fallo a través de la propiedad cause. La propiedad failureType especifica qué estaba haciendo la prueba 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`

Mientras se usa TLS, el nombre de host/IP del par no coincidía 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 claves Diffie-Hellman (DH) es demasiado pequeño. Por defecto, la longitud de la clave debe ser mayor o igual a 1024 bits para evitar vulnerabilidades, aunque se recomienda encarecidamente usar 2048 bits o más para una mayor seguridad.

`ERR_TLS_HANDSHAKE_TIMEOUT`

Se agotó el tiempo de espera de un protocolo de enlace TLS/SSL. En este caso, el servidor también debe abortar la conexión.

`ERR_TLS_INVALID_CONTEXT`

Añadido 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`

Añadido 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 desactivada.

`ERR_TLS_REQUIRED_SERVER_NAME`

Al usar 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 que es un vector potencial para ataques de denegación de servicio.

`ERR_TLS_SNI_FROM_SERVER`

Se intentó emitir una 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 eventos de rastreo.

`ERR_TRACE_EVENTS_UNAVAILABLE`

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

`ERR_TRANSFORM_ALREADY_TRANSFORMING`

Un flujo Transform terminó mientras todavía estaba transformando.

`ERR_TRANSFORM_WITH_LENGTH_0`

Un stream 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 la 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 la sobrescritura accidental de una devolución de llamada registrada desde otro módulo.

`ERR_UNESCAPED_CHARACTERS`

Se recibió una cadena que contenía caracteres no escapados.

`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 no debería ser provocado 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 ha pasado un identificador de grupo o usuario de Unix que no existe.

`ERR_UNKNOWN_ENCODING`

Se ha pasado 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 compatible.

`ERR_UNKNOWN_MODULE_FORMAT`

[Estable: 1 - Experimental]

Estable: 1 Estabilidad: 1 - Experimental

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

`ERR_UNKNOWN_SIGNAL`

Se ha pasado una señal de proceso no válida o desconocida a una API que esperaba una señal válida (como subprocess.kill()).

`ERR_UNSUPPORTED_DIR_IMPORT`

No se admite import de una URL de directorio. En su lugar, haz una autorreferencia a un paquete usando su nombre y define 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 referenciador de módulo no válido. Esto puede ocurrir al importar o llamar a import.meta.resolve() con:

un especificador desnudo que no es un módulo incorporado de un módulo cuyo esquema de URL no es file.
una URL relativa de 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`

Al usar la API de Temporización del Rendimiento (perf_hooks), no se encontraron tipos de entrada de rendimiento válidos.

`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`

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

`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING_FLAG`

Se invocó una función de retorno 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 se ha vinculado (linkingStatus es 'linked')
Se está vinculando (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`

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

`ERR_VM_MODULE_DIFFERENT_CONTEXT`

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

`ERR_VM_MODULE_LINK_FAILURE`

El módulo no pudo vincularse debido a un error.

`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 de WASI ya se ha iniciado.

`ERR_WASI_NOT_STARTED`

La instancia de WASI no se ha iniciado.

`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 válida de WebAssembly.

`ERR_WORKER_INIT_FAILED`

La inicialización del Worker falló.

`ERR_WORKER_INVALID_EXEC_ARGV`

La opción execArgv pasada al constructor Worker contiene flags no válidos.

`ERR_WORKER_MESSAGING_ERRORED`

Añadido en: v22.5.0

[Estable: 1 - Experimental]

Estable: 1 Estabilidad: 1.1 - Desarrollo activo

El hilo de destino lanzó un error mientras procesaba un mensaje enviado a través de postMessageToThread().

`ERR_WORKER_MESSAGING_FAILED`

Añadido en: v22.5.0

[Estable: 1 - Experimental]

Estable: 1 Estabilidad: 1.1 - Desarrollo activo

El hilo solicitado en postMessageToThread() no es válido o no tiene un listener workerMessage.

`ERR_WORKER_MESSAGING_SAME_THREAD`

Añadido en: v22.5.0

[Estable: 1 - Experimental]

Estable: 1 Estabilidad: 1.1 - Desarrollo activo

El id del hilo solicitado en postMessageToThread() es el id del hilo actual.

`ERR_WORKER_MESSAGING_TIMEOUT`

Agregado en: v22.5.0

[Estable: 1 - Experimental]

Estable: 1 Estabilidad: 1.1 - Desarrollo activo

El envío de un mensaje a través de postMessageToThread() ha excedido el tiempo de espera.

`ERR_WORKER_NOT_RUNNING`

Una operación falló porque la instancia Worker no se está ejecutando actualmente.

`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`

Añadido en: v21.6.2, v20.11.1, v18.19.1

Se recibieron demasiados datos para las extensiones de un fragmento. Para proteger 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`

[Historial]

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

Se recibieron demasiados datos de encabezado HTTP. Para proteger contra clientes maliciosos o mal configurados, si se recibe más de maxHeaderSize datos de encabezado 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 un encabezado 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, el encabezado HTTP Content-Length no se puede usar.

Utilice Content-Length o Transfer-Encoding: chunked.

`MODULE_NOT_FOUND`

[Historial]

Versión	Cambios
v12.0.0	Se agregó 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`

Agregado 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 de process.cpuUsage no pudo ser procesada.

`ERR_CRYPTO_HASH_DIGEST_NO_UTF16`

Agregado 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, lo cual es consistente con otras API.

`ERR_FS_INVALID_SYMLINK_TYPE`

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	En su lugar, se lanza una `DOMException`.
v21.0.0	Eliminado en: v21.0.0
v15.0.0	Agregado en: v15.0.0

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

En las versiones de Node.js anteriores a la 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`

Añadido en: v9.0.0

Eliminado en: v10.0.0

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

`ERR_NAPI_TSFN_START_IDLE_LOOP`

Añadido 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 hilos en un bucle inactivo. Este error indica que se ha producido un error al intentar iniciar el bucle.

`ERR_NAPI_TSFN_STOP_IDLE_LOOP`

Añadido 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 es gestionada por el motor de JavaScript o por Node.js durante la serialización. Tal SharedArrayBuffer no puede ser serializado.

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

`ERR_UNKNOWN_STDIN_TYPE`

Agregado 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 del propio Node.js, aunque es posible que el código de usuario lo provoque.

`ERR_UNKNOWN_STREAM_TYPE`

Agregado 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 del propio Node.js, aunque es posible que el código de usuario lo provoque.

`ERR_V8BREAKITERATOR`

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

`ERR_VALUE_OUT_OF_RANGE`

Agregado 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`

Agregado en: v10.0.0

Eliminado en: v18.1.0, v16.17.0

La función de enlazador devolvió un módulo para el cual falló el enlazado.

`ERR_VM_MODULE_NOT_LINKED`

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

`ERR_WORKER_UNSUPPORTED_EXTENSION`

Agregado 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`

Agregado en: v9.0.0

Eliminado en: v10.0.0

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

Códigos de Error de OpenSSL

Errores de Validez de Tiempo

`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 caducado: 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 caducado.

`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 el mismo certificado no se encuentra 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 referencia CRL del certificado.

`UNABLE_TO_VERIFY_LEAF_SIGNATURE`

No se pudieron verificar las firmas 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 consistentes con el propósito proporcionado.

`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 proporcionado no se puede usar 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 coincidiera 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 coincidiera 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 intercepció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 intercepció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`