Erros

Aplicações em execução no Node.js geralmente experimentarão quatro categorias de erros:

Erros padrão do JavaScript, como <EvalError>, <SyntaxError>, <RangeError>, <ReferenceError>, <TypeError> e <URIError>.
Erros de sistema acionados por restrições do sistema operacional subjacente, como tentar abrir um arquivo que não existe ou tentar enviar dados por um socket fechado.
Erros especificados pelo usuário acionados pelo código do aplicativo.
AssertionErrors são uma classe especial de erro que pode ser acionada quando o Node.js detecta uma violação lógica excepcional que nunca deveria ocorrer. Estes são levantados tipicamente pelo módulo node:assert.

Todos os erros de JavaScript e de sistema levantados pelo Node.js herdam de, ou são instâncias de, a classe padrão do JavaScript <Error> e têm a garantia de fornecer pelo menos as propriedades disponíveis nessa classe.

Propagação e interceptação de erros

O Node.js suporta vários mecanismos para propagar e manipular erros que ocorrem enquanto uma aplicação está em execução. Como esses erros são relatados e tratados depende inteiramente do tipo de Error e do estilo da API que é chamada.

Todos os erros de JavaScript são tratados como exceções que imediatamente geram e lançam um erro usando o mecanismo padrão throw do JavaScript. Estes são tratados usando a construção try…catch fornecida pela linguagem JavaScript.

// Lança com um ReferenceError porque z não está definido.
try {
  const m = 1;
  const n = m + z;
} catch (err) {
  // Manipula o erro aqui.
}

Qualquer uso do mecanismo throw do JavaScript levantará uma exceção que deve ser tratada ou o processo do Node.js sairá imediatamente.

Com poucas exceções, APIs Síncronas (qualquer método de bloqueio que não retorna um <Promise> nem aceita uma função callback, como fs.readFileSync), usarão throw para relatar erros.

Erros que ocorrem dentro de APIs Assíncronas podem ser relatados de várias maneiras:

Alguns métodos assíncronos retornam um <Promise>, você deve sempre levar em conta que ele pode ser rejeitado. Veja o flag --unhandled-rejections para saber como o processo reagirá a uma rejeição de promise não tratada.
A maioria dos métodos assíncronos que aceitam uma função callback aceitarão um objeto Error passado como o primeiro argumento para essa função. Se esse primeiro argumento não for null e for uma instância de Error, então ocorreu um erro que deve ser tratado.
Quando um método assíncrono é chamado em um objeto que é um EventEmitter, os erros podem ser encaminhados para o evento 'error' desse objeto.
Um punhado de métodos tipicamente assíncronos na API do Node.js ainda pode usar o mecanismo throw para levantar exceções que devem ser tratadas usando try…catch. Não há uma lista abrangente de tais métodos; por favor, consulte a documentação de cada método para determinar o mecanismo de tratamento de erros apropriado necessário.

O uso do mecanismo de evento 'error' é mais comum para APIs baseadas em stream e baseadas em emissor de eventos, que em si representam uma série de operações assíncronas ao longo do tempo (em vez de uma única operação que pode passar ou falhar).

Para todos os objetos EventEmitter, se um manipulador de evento 'error' não for fornecido, o erro será lançado, fazendo com que o processo do Node.js relate uma exceção não capturada e falhe, a menos que: um manipulador tenha sido registrado para o evento 'uncaughtException', ou o módulo obsoleto node:domain seja usado.

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

setImmediate(() => {
  // Isso irá travar o processo porque nenhum manipulador de evento 'error'
  // foi adicionado.
  ee.emit('error', new Error('This will crash'));
});

Erros gerados desta forma não podem ser interceptados usando try…catch, pois são lançados depois que o código de chamada já saiu.

Os desenvolvedores devem consultar a documentação de cada método para determinar exatamente como os erros levantados por esses métodos são propagados.

Classe: `Error`

Um objeto JavaScript <Error> genérico que não denota nenhuma circunstância específica do porquê do erro ter ocorrido. Os objetos Error capturam um "rastreamento de pilha" detalhando o ponto no código em que o Error foi instanciado e podem fornecer uma descrição textual do erro.

Todos os erros gerados pelo Node.js, incluindo todos os erros de sistema e JavaScript, serão instâncias de ou herdarão da classe Error.

`new Error(message[, options])`

message <string>
options <Object>
- cause <any> O erro que causou o erro recém-criado.

Cria um novo objeto Error e define a propriedade error.message para a mensagem de texto fornecida. Se um objeto for passado como message, a mensagem de texto será gerada chamando String(message). Se a opção cause for fornecida, ela será atribuída à propriedade error.cause. A propriedade error.stack representará o ponto no código em que new Error() foi chamado. Os rastreamentos de pilha dependem da API de rastreamento de pilha do V8. Os rastreamentos de pilha se estendem apenas até (a) o início da execução síncrona do código ou (b) o número de quadros fornecido pela propriedade Error.stackTraceLimit, o que for menor.

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

targetObject <Object>
constructorOpt <Function>

Cria uma propriedade .stack em targetObject, que, quando acessada, retorna uma string representando o local no código em que Error.captureStackTrace() foi chamado.

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

A primeira linha do rastreamento será prefixada com ${myObject.name}: ${myObject.message}.

O argumento opcional constructorOpt aceita uma função. Se fornecido, todos os quadros acima de constructorOpt, incluindo constructorOpt, serão omitidos do rastreamento de pilha gerado.

O argumento constructorOpt é útil para ocultar os detalhes de implementação da geração de erros do usuário. Por exemplo:

function a() {
  b();
}

function b() {
  c();
}

function c() {
  // Crie um erro sem rastreamento de pilha para evitar calcular o rastreamento de pilha duas vezes.
  const { stackTraceLimit } = Error;
  Error.stackTraceLimit = 0;
  const error = new Error();
  Error.stackTraceLimit = stackTraceLimit;

  // Capture o rastreamento de pilha acima da função b
  Error.captureStackTrace(error, b); // Nem a função c nem b estão incluídas no rastreamento de pilha
  throw error;
}

a();

`Error.stackTraceLimit`

<number>

A propriedade Error.stackTraceLimit especifica o número de quadros de pilha coletados por um rastreamento de pilha (seja gerado por new Error().stack ou Error.captureStackTrace(obj)).

O valor padrão é 10, mas pode ser definido para qualquer número JavaScript válido. As alterações afetarão qualquer rastreamento de pilha capturado após a alteração do valor.

Se definido como um valor não numérico ou definido como um número negativo, os rastreamentos de pilha não capturarão nenhum quadro.

`error.cause`

Adicionado em: v16.9.0

<any>

Se presente, a propriedade error.cause é a causa subjacente do Error. É usado ao capturar um erro e lançar um novo com uma mensagem ou código diferente para ainda ter acesso ao erro original.

A propriedade error.cause é normalmente definida chamando new Error(message, { cause }). Não é definido pelo construtor se a opção cause não for fornecida.

Esta propriedade permite que os erros sejam encadeados. Ao serializar objetos Error, util.inspect() serializa recursivamente error.cause se estiver definido.

const cause = new Error('O servidor HTTP remoto respondeu com um status 500');
const symptom = new Error('A mensagem não foi enviada', { cause });

console.log(symptom);
// Prints:
//   Error: A mensagem não foi enviada
//       at REPL2:1:17
//       at Script.runInThisContext (node:vm:130:12)
//       ... 7 lines matching cause stack trace ...
//       at [_line] [as _line] (node:internal/readline/interface:886:18) {
//     [cause]: Error: O servidor HTTP remoto respondeu com um status 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>

A propriedade error.code é um rótulo de string que identifica o tipo de erro. error.code é a maneira mais estável de identificar um erro. Ele só mudará entre as versões principais do Node.js. Em contraste, as strings error.message podem mudar entre quaisquer versões do Node.js. Veja códigos de erro do Node.js para detalhes sobre códigos específicos.

`error.message`

<string>

A propriedade error.message é a descrição em string do erro conforme definido chamando new Error(message). A message passada para o construtor também aparecerá na primeira linha do rastreamento de pilha do Error, no entanto, alterar esta propriedade após a criação do objeto Error pode não alterar a primeira linha do rastreamento de pilha (por exemplo, quando error.stack é lido antes que esta propriedade seja alterada).

const err = new Error('The message');
console.error(err.message);
// Prints: The message

`error.stack`

<string>

A propriedade error.stack é uma string que descreve o ponto no código em que o Error foi instanciado.

bash

Error: Things keep happening!
   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)

A primeira linha é formatada como \<nome da classe de erro\>: \<mensagem de erro\>, e é seguida por uma série de quadros de pilha (cada linha começando com "at "). Cada quadro descreve um local de chamada dentro do código que levou à geração do erro. O V8 tenta exibir um nome para cada função (por nome de variável, nome de função ou nome de método de objeto), mas ocasionalmente não consegue encontrar um nome adequado. Se o V8 não conseguir determinar um nome para a função, apenas informações de localização serão exibidas para esse quadro. Caso contrário, o nome da função determinado será exibido com informações de localização anexadas entre parênteses.

Os quadros são gerados apenas para funções JavaScript. Se, por exemplo, a execução passar de forma síncrona por meio de uma função de complemento C++ chamada cheetahify que ela própria chama uma função JavaScript, o quadro que representa a chamada cheetahify não estará presente nos rastreamentos de pilha:

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

function makeFaster() {
  // `cheetahify()` chama *sincronamente* speedy.
  cheetahify(function speedy() {
    throw new Error('oh no!');
  });
}

makeFaster();
// will throw:
//   /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

As informações de localização serão uma das seguintes:

native, se o quadro representar uma chamada interna ao V8 (como em [].forEach).
plain-filename.js:line:column, se o quadro representar uma chamada interna ao Node.js.
/absolute/path/to/file.js:line:column, se o quadro representar uma chamada em um programa de usuário (usando o sistema de módulos CommonJS) ou suas dependências.
\<transport-protocol\>:///url/to/module/file.mjs:line:column, se o quadro representar uma chamada em um programa de usuário (usando o sistema de módulos ES) ou suas dependências.

A string que representa o rastreamento de pilha é gerada preguiçosamente quando a propriedade error.stack é acessada.

O número de quadros capturados pelo rastreamento de pilha é limitado pelo menor entre Error.stackTraceLimit ou o número de quadros disponíveis no tick atual do loop de eventos.

Classe: `AssertionError`

Estende: <errors.Error>

Indica a falha de uma asserção. Para detalhes, veja Classe: assert.AssertionError.

Classe: `RangeError`

Estende: <errors.Error>

Indica que um argumento fornecido não estava dentro do conjunto ou intervalo de valores aceitáveis para uma função; seja um intervalo numérico ou fora do conjunto de opções para um determinado parâmetro de função.

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

Node.js irá gerar e lançar instâncias de RangeError imediatamente como uma forma de validação de argumentos.

Classe: `ReferenceError`

Estende: <errors.Error>

Indica que está sendo feita uma tentativa de acessar uma variável que não está definida. Esses erros geralmente indicam erros de digitação no código ou um programa quebrado.

Embora o código do cliente possa gerar e propagar esses erros, na prática, apenas o V8 o fará.

doesNotExist;
// Lança ReferenceError, doesNotExist não é uma variável neste programa.

A menos que um aplicativo esteja gerando e executando código dinamicamente, as instâncias de ReferenceError indicam um bug no código ou em suas dependências.

Classe: `SyntaxError`

Estende: <errors.Error>

Indica que um programa não é JavaScript válido. Esses erros só podem ser gerados e propagados como resultado da avaliação do código. A avaliação do código pode acontecer como resultado de eval, Function, require ou vm. Esses erros são quase sempre indicativos de um programa quebrado.

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

As instâncias de SyntaxError são irrecuperáveis no contexto que as criou – elas só podem ser capturadas por outros contextos.

Classe: `SystemError`

Estende: <errors.Error>

Node.js gera erros de sistema quando ocorrem exceções em seu ambiente de tempo de execução. Isso geralmente ocorre quando um aplicativo viola uma restrição do sistema operacional. Por exemplo, um erro de sistema ocorrerá se um aplicativo tentar ler um arquivo que não existe.

address <string> Se presente, o endereço para o qual uma conexão de rede falhou
code <string> O código de erro string
dest <string> Se presente, o caminho do arquivo de destino ao relatar um erro do sistema de arquivos
errno <number> O número de erro fornecido pelo sistema
info <Object> Se presente, detalhes extras sobre a condição de erro
message <string> Uma descrição legível por humanos do erro fornecida pelo sistema
path <string> Se presente, o caminho do arquivo ao relatar um erro do sistema de arquivos
port <number> Se presente, a porta de conexão de rede que não está disponível
syscall <string> O nome da chamada de sistema que acionou o erro

`error.address`

<string>

Se presente, error.address é uma string que descreve o endereço para o qual uma conexão de rede falhou.

`error.code`

<string>

A propriedade error.code é uma string que representa o código de erro.

`error.dest`

<string>

Se presente, error.dest é o caminho do arquivo de destino ao relatar um erro do sistema de arquivos.

`error.errno`

<number>

A propriedade error.errno é um número negativo que corresponde ao código de erro definido em libuv Error handling.

No Windows, o número de erro fornecido pelo sistema será normalizado pelo libuv.

Para obter a representação de string do código de erro, use util.getSystemErrorName(error.errno).

`error.info`

<Object>

Se presente, error.info é um objeto com detalhes sobre a condição de erro.

`error.message`

<string>

error.message é uma descrição legível por humanos do erro fornecida pelo sistema.

`error.path`

<string>

Se presente, error.path é uma string contendo um nome de caminho inválido relevante.

`error.port`

<number>

Se presente, error.port é a porta de conexão de rede que não está disponível.

`error.syscall`

<string>

A propriedade error.syscall é uma string que descreve a syscall que falhou.

Erros comuns do sistema

Esta é uma lista de erros de sistema comumente encontrados ao escrever um programa Node.js. Para uma lista abrangente, consulte a página man errno(3).

EACCES (Permissão negada): Foi feita uma tentativa de acessar um arquivo de uma forma proibida por suas permissões de acesso ao arquivo.
EADDRINUSE (Endereço já em uso): Uma tentativa de vincular um servidor (net, http ou https) a um endereço local falhou devido a outro servidor no sistema local já estar ocupando esse endereço.
ECONNREFUSED (Conexão recusada): Nenhuma conexão pôde ser feita porque a máquina de destino a recusou ativamente. Isso geralmente resulta da tentativa de conectar a um serviço que está inativo no host estrangeiro.
ECONNRESET (Conexão redefinida pelo par): Uma conexão foi fechada à força por um par. Isso normalmente resulta de uma perda de conexão no socket remoto devido a um tempo limite ou reinicialização. Comumente encontrado através dos módulos http e net.
EEXIST (Arquivo existe): Um arquivo existente era o alvo de uma operação que exigia que o alvo não existisse.
EISDIR (É um diretório): Uma operação esperava um arquivo, mas o nome do caminho fornecido era um diretório.
EMFILE (Muitos arquivos abertos no sistema): O número máximo de descritores de arquivo permitido no sistema foi atingido e as solicitações para outro descritor não podem ser atendidas até que pelo menos um tenha sido fechado. Isso é encontrado ao abrir muitos arquivos ao mesmo tempo em paralelo, especialmente em sistemas (em particular, macOS) onde há um limite baixo de descritores de arquivo para processos. Para remediar um limite baixo, execute ulimit -n 2048 no mesmo shell que executará o processo Node.js.
ENOENT (Nenhum arquivo ou diretório): Comumente levantado por operações fs para indicar que um componente do nome do caminho especificado não existe. Nenhuma entidade (arquivo ou diretório) pôde ser encontrada pelo caminho fornecido.
ENOTDIR (Não é um diretório): Um componente do nome do caminho fornecido existia, mas não era um diretório como esperado. Comumente levantado por fs.readdir.
ENOTEMPTY (Diretório não vazio): Um diretório com entradas era o alvo de uma operação que exige um diretório vazio, geralmente fs.unlink.
ENOTFOUND (Falha na pesquisa de DNS): Indica uma falha de DNS de EAI_NODATA ou EAI_NONAME. Este não é um erro POSIX padrão.
EPERM (Operação não permitida): Foi feita uma tentativa de realizar uma operação que exige privilégios elevados.
EPIPE (Broken pipe): Uma escrita em um pipe, socket ou FIFO para o qual não há processo para ler os dados. Comumente encontrado nas camadas net e http, indicativo de que o lado remoto do stream que está sendo gravado foi fechado.
ETIMEDOUT (Tempo limite da operação): Uma solicitação de conexão ou envio falhou porque a parte conectada não respondeu adequadamente após um período de tempo. Geralmente encontrado por http ou net. Frequentemente, um sinal de que um socket.end() não foi chamado corretamente.

Classe: `TypeError`

Estende <errors.Error>

Indica que um argumento fornecido não é um tipo permitido. Por exemplo, passar uma função para um parâmetro que espera uma string geraria um TypeError.

require('node:url').parse(() => { });
// Lança TypeError, pois esperava uma string.

O Node.js irá gerar e lançar instâncias de TypeError imediatamente como uma forma de validação de argumento.

Exceções vs. erros

Uma exceção JavaScript é um valor que é lançado como resultado de uma operação inválida ou como o alvo de uma declaração throw. Embora não seja obrigatório que esses valores sejam instâncias de Error ou classes que herdam de Error, todas as exceções lançadas pelo Node.js ou pelo tempo de execução do JavaScript serão instâncias de Error.

Algumas exceções são irrecuperáveis na camada JavaScript. Tais exceções sempre farão com que o processo Node.js falhe. Exemplos incluem verificações assert() ou chamadas abort() na camada C++.

Erros OpenSSL

Erros originários em crypto ou tls são da classe Error e, além das propriedades padrão .code e .message, podem ter algumas propriedades adicionais específicas do OpenSSL.

`error.opensslErrorStack`

Um array de erros que pode fornecer contexto sobre onde na biblioteca OpenSSL um erro se origina.

`error.function`

A função OpenSSL em que o erro se origina.

`error.library`

A biblioteca OpenSSL em que o erro se origina.

`error.reason`

Uma string legível descrevendo o motivo do erro.

Códigos de erro do Node.js

`ABORT_ERR`

Adicionado em: v15.0.0

Usado quando uma operação foi abortada (normalmente usando um AbortController).

APIs que não usam AbortSignals normalmente não levantam um erro com este código.

Este código não usa a convenção regular ERR_* que os erros do Node.js usam para ser compatível com o AbortError da plataforma web.

`ERR_ACCESS_DENIED`

Um tipo especial de erro que é acionado sempre que o Node.js tenta obter acesso a um recurso restrito pelo Modelo de Permissões.

`ERR_AMBIGUOUS_ARGUMENT`

Um argumento de função está sendo usado de uma forma que sugere que a assinatura da função pode ser mal compreendida. Isso é lançado pelo módulo node:assert quando o parâmetro message em assert.throws(block, message) corresponde à mensagem de erro lançada por block porque esse uso sugere que o usuário acredita que message é a mensagem esperada em vez da mensagem que AssertionError exibirá se block não lançar.

`ERR_ARG_NOT_ITERABLE`

Um argumento iterável (ou seja, um valor que funciona com loops for...of) foi exigido, mas não fornecido a uma API do Node.js.

`ERR_ASSERTION`

Um tipo especial de erro que pode ser acionado sempre que o Node.js detecta uma violação de lógica excepcional que nunca deve ocorrer. Estes são levantados normalmente pelo módulo node:assert.

`ERR_ASYNC_CALLBACK`

Foi feita uma tentativa de registrar algo que não é uma função como um callback de AsyncHooks.

`ERR_ASYNC_TYPE`

O tipo de um recurso assíncrono era inválido. Os usuários também podem definir seus próprios tipos se estiverem usando a API pública do incorporador.

`ERR_BROTLI_COMPRESSION_FAILED`

Os dados passados para um stream Brotli não foram compactados com sucesso.

`ERR_BROTLI_INVALID_PARAM`

Uma chave de parâmetro inválida foi passada durante a construção de um stream Brotli.

`ERR_BUFFER_CONTEXT_NOT_AVAILABLE`

Foi feita uma tentativa de criar uma instância de Buffer do Node.js a partir de código de addon ou incorporador, enquanto em um Contexto de engine JS que não está associado a uma instância do Node.js. Os dados passados para o método Buffer terão sido liberados no momento em que o método retornar.

Ao encontrar este erro, uma possível alternativa para criar uma instância de Buffer é criar um Uint8Array normal, que difere apenas no protótipo do objeto resultante. Uint8Arrays são geralmente aceitos em todas as APIs principais do Node.js onde Buffers são; eles estão disponíveis em todos os Contextos.

`ERR_BUFFER_OUT_OF_BOUNDS`

Uma operação fora dos limites de um Buffer foi tentada.

`ERR_BUFFER_TOO_LARGE`

Uma tentativa foi feita para criar um Buffer maior que o tamanho máximo permitido.

`ERR_CANNOT_WATCH_SIGINT`

O Node.js não conseguiu monitorar o sinal SIGINT.

`ERR_CHILD_CLOSED_BEFORE_REPLY`

Um processo filho foi fechado antes que o pai recebesse uma resposta.

`ERR_CHILD_PROCESS_IPC_REQUIRED`

Usado quando um processo filho está sendo bifurcado sem especificar um canal IPC.

`ERR_CHILD_PROCESS_STDIO_MAXBUFFER`

Usado quando o processo principal está tentando ler dados do STDERR/STDOUT do processo filho, e o comprimento dos dados é maior que a opção maxBuffer.

`ERR_CLOSED_MESSAGE_PORT`

[Histórico]

Versão	Mudanças
v16.2.0, v14.17.1	A mensagem de erro foi reintroduzida.
v11.12.0	A mensagem de erro foi removida.
v10.5.0	Adicionado em: v10.5.0

Houve uma tentativa de usar uma instância de MessagePort em um estado fechado, geralmente após .close() ter sido chamado.

`ERR_CONSOLE_WRITABLE_STREAM`

Console foi instanciado sem stream stdout, ou Console tem um stream stdout ou stderr não gravável.

`ERR_CONSTRUCT_CALL_INVALID`

Adicionado em: v12.5.0

Um construtor de classe foi chamado que não é chamável.

`ERR_CONSTRUCT_CALL_REQUIRED`

Um construtor para uma classe foi chamado sem new.

`ERR_CONTEXT_NOT_INITIALIZED`

O contexto vm passado para a API ainda não foi inicializado. Isso pode acontecer quando ocorre um erro (e é capturado) durante a criação do contexto, por exemplo, quando a alocação falha ou o tamanho máximo da pilha de chamadas é atingido quando o contexto é criado.

`ERR_CRYPTO_CUSTOM_ENGINE_NOT_SUPPORTED`

Um mecanismo OpenSSL foi solicitado (por exemplo, através das opções TLS clientCertEngine ou privateKeyEngine) que não é suportado pela versão do OpenSSL que está sendo usada, provavelmente devido ao sinalizador de tempo de compilação OPENSSL_NO_ENGINE.

`ERR_CRYPTO_ECDH_INVALID_FORMAT`

Um valor inválido para o argumento format foi passado para o método getPublicKey() da classe crypto.ECDH().

`ERR_CRYPTO_ECDH_INVALID_PUBLIC_KEY`

Um valor inválido para o argumento key foi passado para o método computeSecret() da classe crypto.ECDH(). Isso significa que a chave pública está fora da curva elíptica.

`ERR_CRYPTO_ENGINE_UNKNOWN`

Um identificador de mecanismo criptográfico inválido foi passado para require('node:crypto').setEngine().

`ERR_CRYPTO_FIPS_FORCED`

O argumento de linha de comando --force-fips foi usado, mas houve uma tentativa de habilitar ou desabilitar o modo FIPS no módulo node:crypto.

`ERR_CRYPTO_FIPS_UNAVAILABLE`

Foi feita uma tentativa de habilitar ou desabilitar o modo FIPS, mas o modo FIPS não estava disponível.

`ERR_CRYPTO_HASH_FINALIZED`

hash.digest() foi chamado várias vezes. O método hash.digest() deve ser chamado no máximo uma vez por instância de um objeto Hash.

`ERR_CRYPTO_HASH_UPDATE_FAILED`

hash.update() falhou por algum motivo. Isso raramente, ou nunca, deve acontecer.

`ERR_CRYPTO_INCOMPATIBLE_KEY`

As chaves criptográficas fornecidas são incompatíveis com a operação tentada.

`ERR_CRYPTO_INCOMPATIBLE_KEY_OPTIONS`

A codificação de chave pública ou privada selecionada é incompatível com outras opções.

`ERR_CRYPTO_INITIALIZATION_FAILED`

Adicionado em: v15.0.0

A inicialização do subsistema criptográfico falhou.

`ERR_CRYPTO_INVALID_AUTH_TAG`

Adicionado em: v15.0.0

Uma tag de autenticação inválida foi fornecida.

`ERR_CRYPTO_INVALID_COUNTER`

Adicionado em: v15.0.0

Um contador inválido foi fornecido para uma cifra de modo contador.

`ERR_CRYPTO_INVALID_CURVE`

Adicionado em: v15.0.0

Uma curva elíptica inválida foi fornecida.

O tipo do objeto de chave criptográfica fornecido é inválido para a operação tentada.

`ERR_CRYPTO_INVALID_MESSAGELEN`

Adicionado em: v15.0.0

Um comprimento de mensagem inválido foi fornecido.

`ERR_CRYPTO_INVALID_SCRYPT_PARAMS`

O Node.js foi compilado sem suporte a scrypt. Não é possível com os binários de lançamento oficiais, mas pode acontecer com builds personalizados, incluindo builds de distribuição.

`ERR_CRYPTO_SIGN_KEY_REQUIRED`

Uma chave de assinatura não foi fornecida ao método sign.sign().

`ERR_CRYPTO_TIMING_SAFE_EQUAL_LENGTH`

crypto.timingSafeEqual() foi chamado com argumentos Buffer, TypedArray ou DataView de comprimentos diferentes.

`ERR_CRYPTO_UNKNOWN_CIPHER`

Um cifre desconhecido foi especificado.

`ERR_CRYPTO_UNKNOWN_DH_GROUP`

Um nome de grupo Diffie-Hellman desconhecido foi fornecido. Consulte crypto.getDiffieHellman() para obter uma lista de nomes de grupo válidos.

`ERR_CRYPTO_UNSUPPORTED_OPERATION`

Adicionado em: v15.0.0, v14.18.0

Foi feita uma tentativa de invocar uma operação cripto não suportada.

`ERR_DEBUGGER_ERROR`

Adicionado em: v16.4.0, v14.17.4

Ocorreu um erro com o depurador.

`ERR_DEBUGGER_STARTUP_ERROR`

Adicionado em: v16.4.0, v14.17.4

O depurador atingiu o tempo limite aguardando que o host/porta necessários estivessem livres.

`ERR_DIR_CLOSED`

O fs.Dir foi fechado anteriormente.

`ERR_DIR_CONCURRENT_OPERATION`

Adicionado em: v14.3.0

Uma chamada de leitura ou fechamento síncrona foi tentada em um fs.Dir que possui operações assíncronas em andamento.

`ERR_DLOPEN_DISABLED`

Adicionado em: v16.10.0, v14.19.0

O carregamento de complementos nativos foi desativado usando --no-addons.

`ERR_DLOPEN_FAILED`

Adicionado em: v15.0.0

Uma chamada para process.dlopen() falhou.

`ERR_DNS_SET_SERVERS_FAILED`

c-ares falhou ao definir o servidor DNS.

`ERR_DOMAIN_CALLBACK_NOT_AVAILABLE`

O módulo node:domain não era utilizável, pois não conseguiu estabelecer os hooks de tratamento de erros necessários, porque process.setUncaughtExceptionCaptureCallback() havia sido chamado em um ponto anterior no tempo.

`ERR_DOMAIN_CANNOT_SET_UNCAUGHT_EXCEPTION_CAPTURE`

process.setUncaughtExceptionCaptureCallback() não pôde ser chamado porque o módulo node:domain foi carregado em um ponto anterior no tempo.

O rastreamento de pilha é estendido para incluir o ponto no tempo em que o módulo node:domain foi carregado.

`ERR_DUPLICATE_STARTUP_SNAPSHOT_MAIN_FUNCTION`

v8.startupSnapshot.setDeserializeMainFunction() não pôde ser chamado porque já havia sido chamado antes.

`ERR_ENCODING_INVALID_ENCODED_DATA`

Os dados fornecidos à API TextDecoder() eram inválidos de acordo com a codificação fornecida.

`ERR_ENCODING_NOT_SUPPORTED`

A codificação fornecida à API TextDecoder() não era uma das Codificações Suportadas pelo WHATWG.

`ERR_EVAL_ESM_CANNOT_PRINT`

--print não pode ser usado com entrada ESM.

`ERR_EVENT_RECURSION`

Lançado quando uma tentativa é feita para despachar recursivamente um evento em EventTarget.

`ERR_EXECUTION_ENVIRONMENT_NOT_AVAILABLE`

O contexto de execução JS não está associado a um ambiente Node.js. Isso pode ocorrer quando o Node.js é usado como uma biblioteca incorporada e alguns hooks para o mecanismo JS não estão configurados corretamente.

`ERR_FALSY_VALUE_REJECTION`

Uma Promise que foi callbackificada via util.callbackify() foi rejeitada com um valor falsy.

`ERR_FEATURE_UNAVAILABLE_ON_PLATFORM`

Adicionado em: v14.0.0

Foi feita uma tentativa de copiar para um tipo de arquivo desconhecido com fs.cp().

`ERR_FS_EISDIR`

O caminho é um diretório.

`ERR_FS_FILE_TOO_LARGE`

Foi feita uma tentativa de ler um arquivo cujo tamanho é maior que o tamanho máximo permitido para um Buffer.

`ERR_HTTP2_ALTSVC_INVALID_ORIGIN`

Os quadros HTTP/2 ALTSVC requerem uma origem válida.

`ERR_HTTP2_ALTSVC_LENGTH`

Os quadros HTTP/2 ALTSVC são limitados a um máximo de 16.382 bytes de carga útil.

`ERR_HTTP2_CONNECT_AUTHORITY`

Para solicitações HTTP/2 usando o método CONNECT, o pseudo-cabeçalho :authority é obrigatório.

`ERR_HTTP2_CONNECT_PATH`

Para solicitações HTTP/2 usando o método CONNECT, o pseudo-cabeçalho :path é proibido.

`ERR_HTTP2_CONNECT_SCHEME`

Para solicitações HTTP/2 usando o método CONNECT, o pseudo-cabeçalho :scheme é proibido.

`ERR_HTTP2_ERROR`

Ocorreu um erro HTTP/2 não específico.

`ERR_HTTP2_GOAWAY_SESSION`

Novos Streams HTTP/2 não podem ser abertos depois que o Http2Session recebeu um quadro GOAWAY do peer conectado.

`ERR_HTTP2_HEADERS_AFTER_RESPOND`

Um cabeçalho adicional foi especificado depois que uma resposta HTTP/2 foi iniciada.

`ERR_HTTP2_HEADERS_SENT`

Foi feita uma tentativa de enviar vários cabeçalhos de resposta.

`ERR_HTTP2_HEADER_SINGLE_VALUE`

Vários valores foram fornecidos para um campo de cabeçalho HTTP/2 que era necessário para ter apenas um único valor.

`ERR_HTTP2_INFO_STATUS_NOT_ALLOWED`

Códigos de status HTTP informativos (1xx) não podem ser definidos como o código de status de resposta em respostas HTTP/2.

`ERR_HTTP2_INVALID_CONNECTION_HEADERS`

Os cabeçalhos específicos da conexão HTTP/1 são proibidos de serem usados em solicitações e respostas HTTP/2.

`ERR_HTTP2_INVALID_HEADER_VALUE`

Um valor de cabeçalho HTTP/2 inválido foi especificado.

`ERR_HTTP2_INVALID_INFO_STATUS`

Um código de status informacional HTTP inválido foi especificado. Códigos de status informacionais devem ser um inteiro entre 100 e 199 (inclusive).

`ERR_HTTP2_INVALID_ORIGIN`

Quadros ORIGIN HTTP/2 requerem uma origem válida.

`ERR_HTTP2_INVALID_PACKED_SETTINGS_LENGTH`

Instâncias de Buffer e Uint8Array passadas para a API http2.getUnpackedSettings() devem ter um comprimento que seja um múltiplo de seis.

`ERR_HTTP2_INVALID_PSEUDOHEADER`

Apenas pseudo-cabeçalhos HTTP/2 válidos (:status, :path, :authority, :scheme e :method) podem ser usados.

`ERR_HTTP2_INVALID_SESSION`

Uma ação foi executada em um objeto Http2Session que já havia sido destruído.

`ERR_HTTP2_INVALID_SETTING_VALUE`

Um valor inválido foi especificado para uma configuração HTTP/2.

`ERR_HTTP2_INVALID_STREAM`

Uma operação foi executada em um fluxo que já havia sido destruído.

`ERR_HTTP2_MAX_PENDING_SETTINGS_ACK`

Sempre que um quadro SETTINGS HTTP/2 é enviado a um peer conectado, o peer é obrigado a enviar um reconhecimento de que recebeu e aplicou as novas SETTINGS. Por padrão, um número máximo de quadros SETTINGS não reconhecidos pode ser enviado a qualquer momento. Este código de erro é usado quando esse limite foi atingido.

`ERR_HTTP2_NESTED_PUSH`

Uma tentativa foi feita para iniciar um novo fluxo de push de dentro de um fluxo de push. Fluxos de push aninhados não são permitidos.

`ERR_HTTP2_NO_MEM`

Sem memória ao usar a API http2session.setLocalWindowSize(windowSize).

`ERR_HTTP2_NO_SOCKET_MANIPULATION`

Uma tentativa foi feita para manipular diretamente (ler, escrever, pausar, retomar, etc.) um socket anexado a um Http2Session.

`ERR_HTTP2_ORIGIN_LENGTH`

Quadros ORIGIN HTTP/2 são limitados a um comprimento de 16382 bytes.

`ERR_HTTP2_OUT_OF_STREAMS`

O número de fluxos criados em uma única sessão HTTP/2 atingiu o limite máximo.

`ERR_HTTP2_PAYLOAD_FORBIDDEN`

Um payload de mensagem foi especificado para um código de resposta HTTP para o qual um payload é proibido.

`ERR_HTTP2_PING_CANCEL`

Um ping HTTP/2 foi cancelado.

`ERR_HTTP2_PING_LENGTH`

Os payloads de ping HTTP/2 devem ter exatamente 8 bytes de comprimento.

`ERR_HTTP2_PSEUDOHEADER_NOT_ALLOWED`

Um pseudo-cabeçalho HTTP/2 foi usado de forma inadequada. Pseudo-cabeçalhos são nomes de chaves de cabeçalho que começam com o prefixo :.

`ERR_HTTP2_PUSH_DISABLED`

Foi feita uma tentativa de criar um fluxo de push, que foi desativado pelo cliente.

`ERR_HTTP2_SEND_FILE`

Foi feita uma tentativa de usar a API Http2Stream.prototype.responseWithFile() para enviar um diretório.

`ERR_HTTP2_SEND_FILE_NOSEEK`

Foi feita uma tentativa de usar a API Http2Stream.prototype.responseWithFile() para enviar algo que não seja um arquivo regular, mas as opções offset ou length foram fornecidas.

`ERR_HTTP2_SESSION_ERROR`

O Http2Session fechou com um código de erro diferente de zero.

`ERR_HTTP2_SETTINGS_CANCEL`

As configurações do Http2Session foram canceladas.

`ERR_HTTP2_SOCKET_BOUND`

Foi feita uma tentativa de conectar um objeto Http2Session a um net.Socket ou tls.TLSSocket que já havia sido vinculado a outro objeto Http2Session.

`ERR_HTTP2_SOCKET_UNBOUND`

Foi feita uma tentativa de usar a propriedade socket de um Http2Session que já foi fechado.

`ERR_HTTP2_STATUS_101`

O uso do código de status Informacional 101 é proibido em HTTP/2.

`ERR_HTTP2_STATUS_INVALID`

Um código de status HTTP inválido foi especificado. Os códigos de status devem ser um número inteiro entre 100 e 599 (inclusive).

`ERR_HTTP2_STREAM_CANCEL`

Um Http2Stream foi destruído antes que qualquer dado fosse transmitido ao peer conectado.

`ERR_HTTP2_STREAM_ERROR`

Um código de erro diferente de zero foi especificado em um frame RST_STREAM.

`ERR_HTTP2_STREAM_SELF_DEPENDENCY`

Ao definir a prioridade para um fluxo HTTP/2, o fluxo pode ser marcado como uma dependência para um fluxo pai. Este código de erro é usado quando uma tentativa é feita para marcar um fluxo como dependente de si mesmo.

`ERR_HTTP2_TOO_MANY_CUSTOM_SETTINGS`

O número de configurações personalizadas suportadas (10) foi excedido.

`ERR_HTTP2_TOO_MANY_INVALID_FRAMES`

Adicionado em: v15.14.0

O limite de frames de protocolo HTTP/2 inválidos aceitáveis enviados pelo par, conforme especificado através da opção maxSessionInvalidFrames, foi excedido.

`ERR_HTTP2_TRAILERS_ALREADY_SENT`

Os cabeçalhos de trailer já foram enviados no Http2Stream.

`ERR_HTTP2_TRAILERS_NOT_READY`

O método http2stream.sendTrailers() não pode ser chamado até que o evento 'wantTrailers' seja emitido em um objeto Http2Stream. O evento 'wantTrailers' só será emitido se a opção waitForTrailers estiver definida para o Http2Stream.

`ERR_HTTP2_UNSUPPORTED_PROTOCOL`

http2.connect() recebeu uma URL que usa qualquer protocolo que não seja http: ou https:.

`ERR_HTTP_BODY_NOT_ALLOWED`

Um erro é lançado ao escrever em uma resposta HTTP que não permite conteúdo.

`ERR_HTTP_CONTENT_LENGTH_MISMATCH`

O tamanho do corpo da resposta não corresponde ao valor do cabeçalho content-length especificado.

`ERR_HTTP_HEADERS_SENT`

Uma tentativa foi feita para adicionar mais cabeçalhos depois que os cabeçalhos já haviam sido enviados.

`ERR_HTTP_INVALID_HEADER_VALUE`

Um valor de cabeçalho HTTP inválido foi especificado.

`ERR_HTTP_INVALID_STATUS_CODE`

O código de status estava fora do intervalo de código de status regular (100-999).

`ERR_HTTP_REQUEST_TIMEOUT`

O cliente não enviou a solicitação inteira dentro do tempo permitido.

`ERR_HTTP_SOCKET_ASSIGNED`

O ServerResponse fornecido já foi atribuído a um socket.

`ERR_HTTP_SOCKET_ENCODING`

Alterar a codificação do socket não é permitido de acordo com a RFC 7230 Seção 3.

`ERR_HTTP_TRAILER_INVALID`

O cabeçalho Trailer foi definido mesmo que a codificação de transferência não suporte isso.

`ERR_ILLEGAL_CONSTRUCTOR`

Uma tentativa foi feita para construir um objeto usando um construtor não público.

`ERR_IMPORT_ATTRIBUTE_MISSING`

Adicionado em: v21.1.0

Um atributo de importação está faltando, impedindo que o módulo especificado seja importado.

`ERR_IMPORT_ATTRIBUTE_TYPE_INCOMPATIBLE`

Adicionado em: v21.1.0

Um atributo type de importação foi fornecido, mas o módulo especificado é de um tipo diferente.

`ERR_IMPORT_ATTRIBUTE_UNSUPPORTED`

Adicionado em: v21.0.0, v20.10.0, v18.19.0

Um atributo de importação não é suportado por esta versão do Node.js.

`ERR_INCOMPATIBLE_OPTION_PAIR`

Um par de opções é incompatível entre si e não pode ser usado ao mesmo tempo.

`ERR_INPUT_TYPE_NOT_ALLOWED`

[Estável: 1 - Experimental]

Estável: 1 Estabilidade: 1 - Experimental

A flag --input-type foi usada para tentar executar um arquivo. Esta flag só pode ser usada com entrada via --eval, --print ou STDIN.

`ERR_INSPECTOR_ALREADY_ACTIVATED`

Ao usar o módulo node:inspector, foi feita uma tentativa de ativar o inspetor quando ele já havia começado a escutar em uma porta. Use inspector.close() antes de ativá-lo em um endereço diferente.

`ERR_INSPECTOR_ALREADY_CONNECTED`

Ao usar o módulo node:inspector, foi feita uma tentativa de conectar quando o inspetor já estava conectado.

`ERR_INSPECTOR_CLOSED`

Ao usar o módulo node:inspector, foi feita uma tentativa de usar o inspetor depois que a sessão já havia sido fechada.

`ERR_INSPECTOR_COMMAND`

Ocorreu um erro ao emitir um comando através do módulo node:inspector.

`ERR_INSPECTOR_NOT_ACTIVE`

O inspector não está ativo quando inspector.waitForDebugger() é chamado.

`ERR_INSPECTOR_NOT_AVAILABLE`

O módulo node:inspector não está disponível para uso.

`ERR_INSPECTOR_NOT_CONNECTED`

Ao usar o módulo node:inspector, foi feita uma tentativa de usar o inspetor antes que ele estivesse conectado.

`ERR_INSPECTOR_NOT_WORKER`

Uma API foi chamada na thread principal que só pode ser usada a partir da thread de trabalho.

`ERR_INTERNAL_ASSERTION`

Houve um bug no Node.js ou uso incorreto de internos do Node.js. Para corrigir o erro, abra um problema em https://github.com/nodejs/node/issues.

`ERR_INVALID_ADDRESS`

O endereço fornecido não é compreendido pela API do Node.js.

`ERR_INVALID_ADDRESS_FAMILY`

A família de endereços fornecida não é compreendida pela API do Node.js.

`ERR_INVALID_ARG_TYPE`

Um argumento de tipo incorreto foi passado para uma API do Node.js.

`ERR_INVALID_ARG_VALUE`

Um valor inválido ou não suportado foi passado para um determinado argumento.

`ERR_INVALID_ASYNC_ID`

Um asyncId ou triggerAsyncId inválido foi passado usando AsyncHooks. Um ID menor que -1 nunca deve acontecer.

`ERR_INVALID_BUFFER_SIZE`

Uma troca foi executada em um Buffer, mas seu tamanho não era compatível com a operação.

`ERR_INVALID_CHAR`

Caracteres inválidos foram detectados nos cabeçalhos.

`ERR_INVALID_CURSOR_POS`

Um cursor em um determinado fluxo não pode ser movido para uma linha especificada sem uma coluna especificada.

`ERR_INVALID_FD`

Um descritor de arquivo ('fd') não era válido (por exemplo, era um valor negativo).

`ERR_INVALID_FD_TYPE`

Um tipo de descritor de arquivo ('fd') não era válido.

`ERR_INVALID_FILE_URL_HOST`

Uma API do Node.js que consome URLs file: (como certas funções no módulo fs) encontrou uma URL de arquivo com um host incompatível. Esta situação só pode ocorrer em sistemas do tipo Unix, onde apenas localhost ou um host vazio é suportado.

`ERR_INVALID_FILE_URL_PATH`

Uma API do Node.js que consome URLs file: (como certas funções no módulo fs) encontrou uma URL de arquivo com um caminho incompatível. A semântica exata para determinar se um caminho pode ser usado depende da plataforma.

`ERR_INVALID_HANDLE_TYPE`

Foi feita uma tentativa de enviar um "handle" não suportado por um canal de comunicação IPC para um processo filho. Consulte subprocess.send() e process.send() para obter mais informações.

`ERR_INVALID_HTTP_TOKEN`

Um token HTTP inválido foi fornecido.

`ERR_INVALID_IP_ADDRESS`

Um endereço IP não é válido.

`ERR_INVALID_MIME_SYNTAX`

A sintaxe de um MIME não é válida.

`ERR_INVALID_MODULE`

Adicionado em: v15.0.0, v14.18.0

Foi feita uma tentativa de carregar um módulo que não existe ou que não era válido de outra forma.

`ERR_INVALID_MODULE_SPECIFIER`

A string do módulo importado é um URL inválido, nome de pacote ou especificador de subcaminho de pacote.

`ERR_INVALID_OBJECT_DEFINE_PROPERTY`

Ocorreu um erro ao definir um atributo inválido na propriedade de um objeto.

`ERR_INVALID_PACKAGE_CONFIG`

Um arquivo package.json inválido falhou ao analisar.

`ERR_INVALID_PACKAGE_TARGET`

O campo "exports" do package.json contém um valor de mapeamento de destino inválido para a resolução de módulo tentada.

`ERR_INVALID_PROTOCOL`

Um options.protocol inválido foi passado para http.request().

`ERR_INVALID_REPL_EVAL_CONFIG`

As opções breakEvalOnSigint e eval foram definidas na configuração REPL, o que não é suportado.

`ERR_INVALID_REPL_INPUT`

A entrada não pode ser usada no REPL. As condições sob as quais este erro é usado são descritas na documentação do REPL.

`ERR_INVALID_RETURN_PROPERTY`

Lançado caso uma opção de função não forneça um valor válido para uma de suas propriedades de objeto retornadas na execução.

`ERR_INVALID_RETURN_PROPERTY_VALUE`

Lançado caso uma opção de função não forneça um tipo de valor esperado para uma de suas propriedades de objeto retornadas na execução.

`ERR_INVALID_RETURN_VALUE`

Lançado caso uma opção de função não retorne um tipo de valor esperado na execução, como quando se espera que uma função retorne uma promise.

`ERR_INVALID_STATE`

Adicionado em: v15.0.0

Indica que uma operação não pode ser concluída devido a um estado inválido. Por exemplo, um objeto já pode ter sido destruído ou pode estar realizando outra operação.

`ERR_INVALID_SYNC_FORK_INPUT`

Um Buffer, TypedArray, DataView ou string foi fornecido como entrada stdio para um fork assíncrono. Consulte a documentação do módulo child_process para obter mais informações.

`ERR_INVALID_THIS`

Uma função da API do Node.js foi chamada com um valor this incompatível.

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

const buf = Buffer.alloc(1);
urlSearchParams.has.call(buf, 'foo');
// Lança um TypeError com o código 'ERR_INVALID_THIS'

`ERR_INVALID_TUPLE`

Um elemento no iterável fornecido ao construtor URLSearchParams WHATWG não representou uma tupla [nome, valor] – isto é, se um elemento não é iterável, ou não consiste em exatamente dois elementos.

`ERR_INVALID_TYPESCRIPT_SYNTAX`

Adicionado em: v23.0.0

A sintaxe TypeScript fornecida não é válida ou não é suportada. Isso pode acontecer ao usar a sintaxe TypeScript que requer transformação com remoção de tipo.

`ERR_INVALID_URI`

Um URI inválido foi passado.

`ERR_INVALID_URL`

Uma URL inválida foi passada para o construtor URL WHATWG ou para o legado url.parse() para ser analisado. O objeto de erro lançado normalmente tem uma propriedade adicional 'input' que contém a URL que falhou ao analisar.

`ERR_INVALID_URL_SCHEME`

Uma tentativa foi feita para usar uma URL de um esquema (protocolo) incompatível para um propósito específico. É usado apenas no suporte da API URL WHATWG no módulo fs (que aceita apenas URLs com esquema 'file'), mas pode ser usado em outras APIs do Node.js também no futuro.

`ERR_IPC_CHANNEL_CLOSED`

Uma tentativa foi feita para usar um canal de comunicação IPC que já estava fechado.

`ERR_IPC_DISCONNECTED`

Uma tentativa foi feita para desconectar um canal de comunicação IPC que já estava desconectado. Veja a documentação para o módulo child_process para mais informações.

`ERR_IPC_ONE_PIPE`

Uma tentativa foi feita para criar um processo Node.js filho usando mais de um canal de comunicação IPC. Veja a documentação para o módulo child_process para mais informações.

`ERR_IPC_SYNC_FORK`

Foi feita uma tentativa de abrir um canal de comunicação IPC com um processo Node.js bifurcado sincronicamente. Consulte a documentação do módulo child_process para obter mais informações.

`ERR_IP_BLOCKED`

O IP está bloqueado por net.BlockList.

`ERR_LOADER_CHAIN_INCOMPLETE`

Adicionado em: v18.6.0, v16.17.0

Um gancho do carregador ESM retornou sem chamar next() e sem sinalizar explicitamente um curto-circuito.

`ERR_LOAD_SQLITE_EXTENSION`

Adicionado em: v23.5.0

Ocorreu um erro ao carregar uma extensão SQLite.

`ERR_MEMORY_ALLOCATION_FAILED`

Foi feita uma tentativa de alocar memória (geralmente na camada C++), mas falhou.

`ERR_MESSAGE_TARGET_CONTEXT_UNAVAILABLE`

Adicionado em: v14.5.0, v12.19.0

Uma mensagem enviada para uma MessagePort não pôde ser desserializada no Context vm de destino. Nem todos os objetos Node.js podem ser instanciados com sucesso em qualquer contexto neste momento, e tentar transferi-los usando postMessage() pode falhar no lado receptor nesse caso.

`ERR_METHOD_NOT_IMPLEMENTED`

Um método é necessário, mas não implementado.

`ERR_MISSING_ARGS`

Um argumento necessário de uma API Node.js não foi passado. Isso é usado apenas para estrita conformidade com a especificação da API (que em alguns casos pode aceitar func(undefined) mas não func()). Na maioria das APIs nativas do Node.js, func(undefined) e func() são tratados de forma idêntica, e o código de erro ERR_INVALID_ARG_TYPE pode ser usado em vez disso.

`ERR_MISSING_OPTION`

Para APIs que aceitam objetos de opções, algumas opções podem ser obrigatórias. Este código é lançado se uma opção necessária estiver faltando.

`ERR_MISSING_PASSPHRASE`

Foi feita uma tentativa de ler uma chave criptografada sem especificar uma senha.

`ERR_MISSING_PLATFORM_FOR_WORKER`

A plataforma V8 usada por esta instância do Node.js não oferece suporte à criação de Workers. Isso é causado pela falta de suporte do incorporador para Workers. Em particular, este erro não ocorrerá com builds padrão do Node.js.

`ERR_MODULE_NOT_FOUND`

Um arquivo de módulo não pôde ser resolvido pelo carregador de módulos ECMAScript ao tentar uma operação import ou ao carregar o ponto de entrada do programa.

`ERR_MULTIPLE_CALLBACK`

Um callback foi chamado mais de uma vez.

Um callback quase sempre deve ser chamado apenas uma vez, pois a consulta pode ser atendida ou rejeitada, mas não ambas ao mesmo tempo. O último seria possível chamando um callback mais de uma vez.

`ERR_NAPI_CONS_FUNCTION`

Ao usar Node-API, um construtor passado não era uma função.

`ERR_NAPI_INVALID_DATAVIEW_ARGS`

Ao chamar napi_create_dataview(), um offset fornecido estava fora dos limites do dataview ou offset + length era maior que um comprimento de buffer fornecido.

`ERR_NAPI_INVALID_TYPEDARRAY_ALIGNMENT`

Ao chamar napi_create_typedarray(), o offset fornecido não era um múltiplo do tamanho do elemento.

`ERR_NAPI_INVALID_TYPEDARRAY_LENGTH`

Ao chamar napi_create_typedarray(), (length * size_of_element) + byte_offset era maior que o comprimento do buffer fornecido.

`ERR_NAPI_TSFN_CALL_JS`

Ocorreu um erro ao invocar a parte JavaScript da função thread-safe.

`ERR_NAPI_TSFN_GET_UNDEFINED`

Ocorreu um erro ao tentar recuperar o valor JavaScript undefined.

`ERR_NON_CONTEXT_AWARE_DISABLED`

Um addon nativo não context-aware foi carregado em um processo que os proíbe.

`ERR_NOT_BUILDING_SNAPSHOT`

Foi feita uma tentativa de usar operações que só podem ser usadas ao construir um snapshot de inicialização do V8, mesmo que o Node.js não esteja construindo um.

`ERR_NOT_IN_SINGLE_EXECUTABLE_APPLICATION`

Adicionado em: v21.7.0, v20.12.0

A operação não pode ser realizada quando não está em um aplicativo de executável único.

`ERR_NOT_SUPPORTED_IN_SNAPSHOT`

Foi feita uma tentativa de realizar operações que não são suportadas ao construir um snapshot de inicialização.

`ERR_NO_CRYPTO`

Foi feita uma tentativa de usar recursos criptográficos enquanto o Node.js não foi compilado com suporte criptográfico OpenSSL.

`ERR_NO_ICU`

Foi feita uma tentativa de usar recursos que exigem ICU, mas o Node.js não foi compilado com suporte ao ICU.

`ERR_NO_TYPESCRIPT`

Adicionado em: v23.0.0

Foi feita uma tentativa de usar recursos que exigem suporte nativo ao TypeScript, mas o Node.js não foi compilado com suporte ao TypeScript.

`ERR_OPERATION_FAILED`

Adicionado em: v15.0.0

Uma operação falhou. Isso é normalmente usado para sinalizar a falha geral de uma operação assíncrona.

`ERR_OUT_OF_RANGE`

Um valor fornecido está fora do intervalo aceito.

`ERR_PACKAGE_IMPORT_NOT_DEFINED`

O campo "imports" do package.json não define o mapeamento de especificador de pacote interno fornecido.

`ERR_PACKAGE_PATH_NOT_EXPORTED`

O campo "exports" do package.json não exporta o subcaminho solicitado. Como as exportações são encapsuladas, módulos internos privados que não são exportados não podem ser importados através da resolução de pacotes, a menos que se use um URL absoluto.

`ERR_PARSE_ARGS_INVALID_OPTION_VALUE`

Adicionado em: v18.3.0, v16.17.0

Quando strict está definido como true, lançado por util.parseArgs() se um valor <boolean> for fornecido para uma opção do tipo <string>, ou se um valor <string> for fornecido para uma opção do tipo <boolean>.

`ERR_PARSE_ARGS_UNEXPECTED_POSITIONAL`

Adicionado em: v18.3.0, v16.17.0

Lançado por util.parseArgs(), quando um argumento posicional é fornecido e allowPositionals está definido como false.

`ERR_PARSE_ARGS_UNKNOWN_OPTION`

Adicionado em: v18.3.0, v16.17.0

Quando strict está definido como true, lançado por util.parseArgs() se um argumento não estiver configurado em options.

`ERR_PERFORMANCE_INVALID_TIMESTAMP`

Um valor de timestamp inválido foi fornecido para uma marca ou medida de desempenho.

`ERR_PERFORMANCE_MEASURE_INVALID_OPTIONS`

Estável: 1 Estabilidade: 1 - Experimental

Ao tentar require() um Módulo ES, uma borda CommonJS para ESM ou ESM para CommonJS participa de um ciclo imediato. Isso não é permitido porque os Módulos ES não podem ser avaliados enquanto já estão sendo avaliados.

Para evitar o ciclo, a chamada require() envolvida em um ciclo não deve ocorrer no nível superior de um Módulo ES (via createRequire()) ou um módulo CommonJS, e deve ser feita preguiçosamente em uma função interna.

`ERR_REQUIRE_ESM`

[Histórico]

Versão	Mudanças
v23.0.0	require() agora suporta o carregamento de módulos ES síncronos por padrão.

[Estável: 0 - Obsoleto]

Estável: 0 Estabilidade: 0 - Obsoleto

Foi feita uma tentativa de require() um Módulo ES.

Este erro foi descontinuado, pois require() agora suporta o carregamento de módulos ES síncronos. Quando require() encontra um módulo ES que contém await de nível superior, ele lançará ERR_REQUIRE_ASYNC_MODULE em vez disso.

`ERR_SCRIPT_EXECUTION_INTERRUPTED`

A execução do script foi interrompida por SIGINT (Por exemplo, + foi pressionado.)

`ERR_SCRIPT_EXECUTION_TIMEOUT`

O tempo limite da execução do script expirou, possivelmente devido a bugs no script que está sendo executado.

`ERR_SERVER_ALREADY_LISTEN`

O método server.listen() foi chamado enquanto um net.Server já estava ouvindo. Isso se aplica a todas as instâncias de net.Server, incluindo instâncias Server HTTP, HTTPS e HTTP/2.

`ERR_SERVER_NOT_RUNNING`

O método server.close() foi chamado quando um net.Server não estava em execução. Isso se aplica a todas as instâncias de net.Server, incluindo instâncias HTTP, HTTPS e HTTP/2 Server.

`ERR_SINGLE_EXECUTABLE_APPLICATION_ASSET_NOT_FOUND`

Adicionado em: v21.7.0, v20.12.0

Uma chave foi passada para as APIs de aplicação executável única para identificar um recurso, mas nenhuma correspondência pôde ser encontrada.

`ERR_SOCKET_ALREADY_BOUND`

Foi feita uma tentativa de vincular um socket que já foi vinculado.

`ERR_SOCKET_BAD_BUFFER_SIZE`

Um tamanho inválido (negativo) foi passado para as opções recvBufferSize ou sendBufferSize em dgram.createSocket().

`ERR_SOCKET_BAD_PORT`

Uma função da API esperando uma porta >= 0 e < 65536 recebeu um valor inválido.

`ERR_SOCKET_BAD_TYPE`

Uma função da API esperando um tipo de socket (udp4 ou udp6) recebeu um valor inválido.

`ERR_SOCKET_BUFFER_SIZE`

Ao usar dgram.createSocket(), o tamanho do Buffer de recebimento ou envio não pôde ser determinado.

`ERR_SOCKET_CLOSED`

Foi feita uma tentativa de operar em um socket já fechado.

`ERR_SOCKET_CLOSED_BEFORE_CONNECTION`

Ao chamar net.Socket.write() em um socket de conexão e o socket foi fechado antes que a conexão fosse estabelecida.

`ERR_SOCKET_CONNECTION_TIMEOUT`

O socket não conseguiu se conectar a nenhum endereço retornado pelo DNS dentro do tempo limite permitido ao usar o algoritmo de autoseleção de família.

`ERR_SOCKET_DGRAM_IS_CONNECTED`

Uma chamada dgram.connect() foi feita em um socket já conectado.

`ERR_SOCKET_DGRAM_NOT_CONNECTED`

Uma chamada dgram.disconnect() ou dgram.remoteAddress() foi feita em um socket desconectado.

`ERR_SOCKET_DGRAM_NOT_RUNNING`

Uma chamada foi feita e o subsistema UDP não estava em execução.

`ERR_SOURCE_MAP_CORRUPT`

O mapa de origem não pôde ser analisado porque não existe ou está corrompido.

`ERR_SOURCE_MAP_MISSING_SOURCE`

Um arquivo importado de um mapa de origem não foi encontrado.

`ERR_SQLITE_ERROR`

Adicionado em: v22.5.0

Um erro foi retornado de SQLite.

`ERR_SRI_PARSE`

Uma string foi fornecida para uma verificação de Integridade de Sub-recurso, mas não pôde ser analisada. Verifique o formato dos atributos de integridade consultando a especificação de Integridade de Sub-recurso.

`ERR_STREAM_ALREADY_FINISHED`

Um método de stream foi chamado que não pode ser concluído porque o stream foi finalizado.

`ERR_STREAM_CANNOT_PIPE`

Foi feita uma tentativa de chamar stream.pipe() em um stream Writable.

`ERR_STREAM_DESTROYED`

Um método de stream foi chamado que não pode ser concluído porque o stream foi destruído usando stream.destroy().

`ERR_STREAM_NULL_VALUES`

Foi feita uma tentativa de chamar stream.write() com um chunk null.

`ERR_STREAM_PREMATURE_CLOSE`

Um erro retornado por stream.finished() e stream.pipeline(), quando um stream ou um pipeline termina de forma não elegante sem nenhum erro explícito.

`ERR_STREAM_PUSH_AFTER_EOF`

Foi feita uma tentativa de chamar stream.push() após um null (EOF) ter sido enviado para o stream.

`ERR_STREAM_UNABLE_TO_PIPE`

Foi feita uma tentativa de canalizar para um stream fechado ou destruído em um pipeline.

`ERR_STREAM_UNSHIFT_AFTER_END_EVENT`

Foi feita uma tentativa de chamar stream.unshift() após o evento 'end' ter sido emitido.

`ERR_STREAM_WRAP`

Impede uma interrupção se um decodificador de string foi definido no Socket ou se o decodificador está em objectMode.

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

instance.setEncoding('utf8');

`ERR_STREAM_WRITE_AFTER_END`

Foi feita uma tentativa de chamar stream.write() após stream.end() ter sido chamado.

`ERR_STRING_TOO_LONG`

Foi feita uma tentativa de criar uma string maior do que o comprimento máximo permitido.

`ERR_SYNTHETIC`

Um objeto de erro artificial usado para capturar a pilha de chamadas para relatórios de diagnóstico.

`ERR_SYSTEM_ERROR`

Ocorreu um erro de sistema não especificado ou não específico dentro do processo Node.js. O objeto de erro terá uma propriedade de objeto err.info com detalhes adicionais.

`ERR_TAP_LEXER_ERROR`

Um erro representando um estado de analisador léxico falhando.

`ERR_TAP_PARSER_ERROR`

Um erro representando um estado de analisador sintático falhando. Informações adicionais sobre o token que causou o erro estão disponíveis através da propriedade cause.

`ERR_TAP_VALIDATION_ERROR`

Este erro representa uma validação TAP falhada.

`ERR_TEST_FAILURE`

Este erro representa um teste falhado. Informações adicionais sobre a falha estão disponíveis através da propriedade cause. A propriedade failureType especifica o que o teste estava fazendo quando a falha ocorreu.

`ERR_TLS_ALPN_CALLBACK_INVALID_RESULT`

Este erro é lançado quando um ALPNCallback retorna um valor que não está na lista de protocolos ALPN oferecidos pelo cliente.

`ERR_TLS_ALPN_CALLBACK_WITH_PROTOCOLS`

Este erro é lançado ao criar um TLSServer se as opções TLS incluem tanto ALPNProtocols quanto ALPNCallback. Estas opções são mutuamente exclusivas.

`ERR_TLS_CERT_ALTNAME_FORMAT`

Este erro é lançado por checkServerIdentity se uma propriedade subjectaltname fornecida pelo usuário violar as regras de codificação. Objetos de certificado produzidos pelo próprio Node.js sempre cumprem as regras de codificação e nunca causarão este erro.

`ERR_TLS_CERT_ALTNAME_INVALID`

Ao usar TLS, o nome de host/IP do par não correspondeu a nenhum dos subjectAltNames em seu certificado.

`ERR_TLS_DH_PARAM_SIZE`

Ao usar TLS, o parâmetro oferecido para o protocolo de acordo de chave Diffie-Hellman (DH) é muito pequeno. Por padrão, o comprimento da chave deve ser maior ou igual a 1024 bits para evitar vulnerabilidades, embora seja fortemente recomendado usar 2048 bits ou mais para uma segurança mais forte.

`ERR_TLS_HANDSHAKE_TIMEOUT`

Um handshake TLS/SSL expirou. Nesse caso, o servidor também deve abortar a conexão.

`ERR_TLS_INVALID_CONTEXT`

Adicionado em: v13.3.0

O contexto deve ser um SecureContext.

`ERR_TLS_INVALID_PROTOCOL_METHOD`

O método secureProtocol especificado é inválido. É desconhecido ou desativado por ser inseguro.

`ERR_TLS_INVALID_PROTOCOL_VERSION`

As versões válidas do protocolo TLS são 'TLSv1', 'TLSv1.1' ou 'TLSv1.2'.

`ERR_TLS_INVALID_STATE`

Adicionado em: v13.10.0, v12.17.0

O socket TLS deve estar conectado e estabelecido com segurança. Certifique-se de que o evento 'secure' seja emitido antes de continuar.

`ERR_TLS_PROTOCOL_VERSION_CONFLICT`

A tentativa de definir um protocolo TLS minVersion ou maxVersion entra em conflito com uma tentativa de definir o secureProtocol explicitamente. Use um mecanismo ou outro.

`ERR_TLS_PSK_SET_IDENTITY_HINT_FAILED`

Falha ao definir a dica de identidade PSK. A dica pode ser muito longa.

`ERR_TLS_RENEGOTIATION_DISABLED`

Uma tentativa foi feita para renegociar o TLS em uma instância de socket com a renegociação desativada.

`ERR_TLS_REQUIRED_SERVER_NAME`

Ao usar TLS, o método server.addContext() foi chamado sem fornecer um nome de host no primeiro parâmetro.

`ERR_TLS_SESSION_ATTACK`

Uma quantidade excessiva de renegociações de TLS é detectada, o que é um vetor potencial para ataques de negação de serviço.

`ERR_TLS_SNI_FROM_SERVER`

Uma tentativa foi feita para emitir a Indicação de Nome do Servidor de um socket TLS do lado do servidor, que é válido apenas de um cliente.

`ERR_TRACE_EVENTS_CATEGORY_REQUIRED`

O método trace_events.createTracing() requer pelo menos uma categoria de evento de rastreamento.

`ERR_TRACE_EVENTS_UNAVAILABLE`

O módulo node:trace_events não pôde ser carregado porque o Node.js foi compilado com a flag --without-v8-platform.

`ERR_TRANSFORM_ALREADY_TRANSFORMING`

Um fluxo Transform terminou enquanto ainda estava transformando.

`ERR_TRANSFORM_WITH_LENGTH_0`

Um fluxo Transform terminou com dados ainda no buffer de escrita.

`ERR_TTY_INIT_FAILED`

A inicialização de um TTY falhou devido a um erro de sistema.

`ERR_UNAVAILABLE_DURING_EXIT`

A função foi chamada dentro de um manipulador process.on('exit') que não deveria ser chamado dentro do manipulador process.on('exit').

`ERR_UNCAUGHT_EXCEPTION_CAPTURE_ALREADY_SET`

process.setUncaughtExceptionCaptureCallback() foi chamado duas vezes, sem primeiro redefinir o callback para null.

Este erro foi projetado para evitar a sobrescrita acidental de um callback registrado de outro módulo.

`ERR_UNESCAPED_CHARACTERS`

Uma string que continha caracteres não escapados foi recebida.

`ERR_UNHANDLED_ERROR`

Ocorreu um erro não tratado (por exemplo, quando um evento 'error' é emitido por um EventEmitter mas um manipulador 'error' não está registrado).

`ERR_UNKNOWN_BUILTIN_MODULE`

Usado para identificar um tipo específico de erro interno do Node.js que normalmente não deve ser acionado pelo código do usuário. Instâncias desse erro apontam para um bug interno dentro do próprio binário do Node.js.

`ERR_UNKNOWN_CREDENTIAL`

Um grupo Unix ou identificador de usuário que não existe foi passado.

`ERR_UNKNOWN_ENCODING`

Uma opção de codificação inválida ou desconhecida foi passada para uma API.

`ERR_UNKNOWN_FILE_EXTENSION`

[Estável: 1 - Experimental]

Estável: 1 Estabilidade: 1 - Experimental

Uma tentativa foi feita para carregar um módulo com uma extensão de arquivo desconhecida ou não suportada.

`ERR_UNKNOWN_MODULE_FORMAT`

[Estável: 1 - Experimental]

Estável: 1 Estabilidade: 1 - Experimental

Uma tentativa foi feita para carregar um módulo com um formato desconhecido ou não suportado.

`ERR_UNKNOWN_SIGNAL`

Um sinal de processo inválido ou desconhecido foi passado para uma API que espera um sinal válido (como subprocess.kill()).

`ERR_UNSUPPORTED_DIR_IMPORT`

import de uma URL de diretório não é suportado. Em vez disso, faça auto-referência a um pacote usando seu nome e defina um subcaminho personalizado no campo "exports" do arquivo package.json.

import './'; // não suportado
import './index.js'; // suportado
import 'nome-do-pacote'; // suportado

`ERR_UNSUPPORTED_ESM_URL_SCHEME`

import com esquemas de URL diferentes de file e data não é suportado.

`ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING`

Adicionado em: v22.6.0

A remoção de tipos não é suportada para arquivos descendentes de um diretório node_modules.

`ERR_UNSUPPORTED_RESOLVE_REQUEST`

Foi feita uma tentativa de resolver um referenciador de módulo inválido. Isso pode acontecer ao importar ou chamar import.meta.resolve() com:

um especificador nu que não é um módulo embutido de um módulo cujo esquema de URL não é file.
uma URL relativa de um módulo cujo esquema de URL não é um esquema especial.

try {
  // Tentando importar o pacote 'bare-specifier' de um módulo URL `data:`:
  await import('data:text/javascript,import "bare-specifier"');
} catch (e) {
  console.log(e.code); // ERR_UNSUPPORTED_RESOLVE_REQUEST
}

`ERR_USE_AFTER_CLOSE`

[Estável: 1 - Experimental]

Estável: 1 Estabilidade: 1 - Experimental

Foi feita uma tentativa de usar algo que já estava fechado.

`ERR_VALID_PERFORMANCE_ENTRY_TYPE`

Ao usar a API de Tempo de Desempenho (perf_hooks), nenhum tipo de entrada de desempenho válido é encontrado.

`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING`

Um callback de importação dinâmica não foi especificado.

`ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING_FLAG`

Um callback de importação dinâmica foi invocado sem --experimental-vm-modules.

`ERR_VM_MODULE_ALREADY_LINKED`

O módulo que tentou ser vinculado não é elegível para vinculação, por um dos seguintes motivos:

Já foi vinculado (linkingStatus é 'linked')
Está sendo vinculado (linkingStatus é 'linking')
A vinculação falhou para este módulo (linkingStatus é 'errored')

`ERR_VM_MODULE_CACHED_DATA_REJECTED`

A opção cachedData passada para um construtor de módulo é inválida.

`ERR_VM_MODULE_CANNOT_CREATE_CACHED_DATA`

Dados em cache não podem ser criados para módulos que já foram avaliados.

`ERR_VM_MODULE_DIFFERENT_CONTEXT`

O módulo que está sendo retornado da função linker é de um contexto diferente do módulo pai. Módulos vinculados devem compartilhar o mesmo contexto.

`ERR_VM_MODULE_LINK_FAILURE`

O módulo não pôde ser vinculado devido a uma falha.

`ERR_VM_MODULE_NOT_MODULE`

O valor cumprido de uma promessa de vinculação não é um objeto vm.Module.

`ERR_VM_MODULE_STATUS`

O status atual do módulo não permite esta operação. O significado específico do erro depende da função específica.

`ERR_WASI_ALREADY_STARTED`

A instância WASI já foi iniciada.

`ERR_WASI_NOT_STARTED`

A instância WASI não foi iniciada.

`ERR_WEBASSEMBLY_RESPONSE`

Adicionado em: v18.1.0

A Response que foi passada para WebAssembly.compileStreaming ou para WebAssembly.instantiateStreaming não é uma resposta WebAssembly válida.

`ERR_WORKER_INIT_FAILED`

`ERR_WORKER_OUT_OF_MEMORY`

A instância Worker terminou porque atingiu seu limite de memória.

`ERR_WORKER_PATH`

O caminho para o script principal de um worker não é um caminho absoluto nem um caminho relativo que começa com ./ ou ../.

`ERR_WORKER_UNSERIALIZABLE_ERROR`

Todas as tentativas de serializar uma exceção não capturada de uma thread worker falharam.

`ERR_WORKER_UNSUPPORTED_OPERATION`

A funcionalidade solicitada não é suportada em threads worker.

`ERR_ZLIB_INITIALIZATION_FAILED`

A criação de um objeto zlib falhou devido à configuração incorreta.

`HPE_CHUNK_EXTENSIONS_OVERFLOW`

Adicionado em: v21.6.2, v20.11.1, v18.19.1

Muitos dados foram recebidos para uma extensão de chunk. Para proteger contra clientes maliciosos ou mal configurados, se mais de 16 KiB de dados forem recebidos, um Error com este código será emitido.

`HPE_HEADER_OVERFLOW`

[Histórico]

Versão	Alterações
v11.4.0, v10.15.0	O tamanho máximo do cabeçalho em `http_parser` foi definido para 8 KiB.

Muitos dados de cabeçalho HTTP foram recebidos. Para proteger contra clientes maliciosos ou mal configurados, se mais do que maxHeaderSize de dados de cabeçalho HTTP forem recebidos, o parsing HTTP será abortado sem que um objeto de requisição ou resposta seja criado, e um Error com este código será emitido.

`HPE_UNEXPECTED_CONTENT_LENGTH`

O servidor está enviando um cabeçalho Content-Length e Transfer-Encoding: chunked.

Transfer-Encoding: chunked permite que o servidor mantenha uma conexão HTTP persistente para conteúdo gerado dinamicamente. Neste caso, o cabeçalho HTTP Content-Length não pode ser usado.

Use Content-Length ou Transfer-Encoding: chunked.

`MODULE_NOT_FOUND`

[Histórico]

Versão	Alterações
v12.0.0	Adicionada a propriedade `requireStack`.

Um arquivo de módulo não pôde ser resolvido pelo carregador de módulos CommonJS ao tentar uma operação require() ou ao carregar o ponto de entrada do programa.

Códigos de erro legados do Node.js

[Estável: 0 - Obsoleto]

Estável: 0 Estabilidade: 0 - Obsoleto. Esses códigos de erro são inconsistentes ou foram removidos.

`ERR_CANNOT_TRANSFER_OBJECT`

Adicionado em: v10.5.0

Removido em: v12.5.0

O valor passado para postMessage() continha um objeto que não é suportado para transferência.

`ERR_CPU_USAGE`

Removido em: v15.0.0

A chamada nativa de process.cpuUsage não pôde ser processada.

`ERR_CRYPTO_HASH_DIGEST_NO_UTF16`

Adicionado em: v9.0.0

Removido em: v12.12.0

A codificação UTF-16 foi usada com hash.digest(). Embora o método hash.digest() permita que um argumento encoding seja passado, fazendo com que o método retorne uma string em vez de um Buffer, a codificação UTF-16 (por exemplo, ucs ou utf16le) não é suportada.

`ERR_CRYPTO_SCRYPT_INVALID_PARAMETER`

Removido em: v23.0.0

Uma combinação incompatível de opções foi passada para crypto.scrypt() ou crypto.scryptSync(). Novas versões do Node.js usam o código de erro ERR_INCOMPATIBLE_OPTION_PAIR em vez disso, o que é consistente com outras APIs.

Este código de erro foi substituído por ERR_MISSING_TRANSFERABLE_IN_TRANSFER_LIST no Node.js v15.0.0, porque não é mais preciso, pois outros tipos de objetos transferíveis também existem agora.

`ERR_MISSING_TRANSFERABLE_IN_TRANSFER_LIST`

[Histórico]

Versão	Mudanças
v21.0.0	Uma `DOMException` é lançada em vez disso.
v21.0.0	Removido em: v21.0.0
v15.0.0	Adicionado em: v15.0.0

Um objeto que precisa ser explicitamente listado no argumento transferList está no objeto passado para uma chamada postMessage(), mas não é fornecido no transferList para essa chamada. Normalmente, este é um MessagePort.

Nas versões do Node.js anteriores à v15.0.0, o código de erro usado aqui era ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST. No entanto, o conjunto de tipos de objetos transferíveis foi expandido para cobrir mais tipos do que MessagePort.

`ERR_NAPI_CONS_PROTOTYPE_OBJECT`

Adicionado em: v9.0.0

Removido em: v10.0.0

Usado pela Node-API quando Constructor.prototype não é um objeto.

`ERR_NAPI_TSFN_START_IDLE_LOOP`

Adicionado em: v10.6.0, v8.16.0

Removido em: v14.2.0, v12.17.0

Na thread principal, os valores são removidos da fila associada à função thread-safe em um loop ocioso. Este erro indica que ocorreu um erro ao tentar iniciar o loop.

`ERR_NAPI_TSFN_STOP_IDLE_LOOP`

Adicionado em: v10.6.0, v8.16.0

Removido em: v14.2.0, v12.17.0

Assim que não houver mais itens na fila, o loop ocioso deve ser suspenso. Este erro indica que o loop ocioso não conseguiu parar.

`ERR_NO_LONGER_SUPPORTED`

Um SharedArrayBuffer cuja memória não é gerenciada pelo mecanismo JavaScript ou pelo Node.js foi encontrado durante a serialização. Tal SharedArrayBuffer não pode ser serializado.

Isso só pode acontecer quando complementos nativos criam SharedArrayBuffers no modo "externalizado" ou colocam SharedArrayBuffers existentes no modo externalizado.

`ERR_UNKNOWN_STDIN_TYPE`

Adicionado em: v8.0.0

Removido em: v11.7.0

Uma tentativa foi feita para iniciar um processo Node.js com um tipo de arquivo stdin desconhecido. Este erro geralmente é uma indicação de um bug dentro do próprio Node.js, embora seja possível que o código do usuário o acione.

`ERR_UNKNOWN_STREAM_TYPE`

Adicionado em: v8.0.0

Removido em: v11.7.0

Uma tentativa foi feita para iniciar um processo Node.js com um tipo de arquivo stdout ou stderr desconhecido. Este erro geralmente é uma indicação de um bug dentro do próprio Node.js, embora seja possível que o código do usuário o acione.

`ERR_V8BREAKITERATOR`

A API V8 BreakIterator foi usada, mas o conjunto de dados ICU completo não está instalado.

`ERR_VALUE_OUT_OF_RANGE`

Adicionado em: v9.0.0

Removido em: v10.0.0

Usado quando um determinado valor está fora do intervalo aceito.

`ERR_VM_MODULE_LINKING_ERRORED`

Adicionado em: v10.0.0

Removido em: v18.1.0, v16.17.0

A função de linker retornou um módulo para o qual a vinculação falhou.

`ERR_VM_MODULE_NOT_LINKED`

O módulo deve ser vinculado com sucesso antes da instanciação.

`ERR_WORKER_UNSUPPORTED_EXTENSION`

Adicionado em: v11.0.0

Removido em: v16.9.0

O nome do caminho usado para o script principal de um worker tem uma extensão de arquivo desconhecida.

`ERR_ZLIB_BINDING_CLOSED`

Adicionado em: v9.0.0

Removido em: v10.0.0

Usado quando uma tentativa é feita para usar um objeto zlib depois que ele já foi fechado.

Códigos de Erro OpenSSL

Erros de Validade de Tempo

`CERT_NOT_YET_VALID`

O certificado ainda não é válido: a data notBefore é posterior à hora atual.

`CERT_HAS_EXPIRED`

O certificado expirou: a data notAfter é anterior à hora atual.

`CRL_NOT_YET_VALID`

A lista de revogação de certificados (CRL) tem uma data de emissão futura.

`CRL_HAS_EXPIRED`

A lista de revogação de certificados (CRL) expirou.

`CERT_REVOKED`

O certificado foi revogado; ele está em uma lista de revogação de certificados (CRL).

`UNABLE_TO_GET_ISSUER_CERT`

O certificado emissor de um certificado procurado não pôde ser encontrado. Isso normalmente significa que a lista de certificados confiáveis não está completa.

`UNABLE_TO_GET_ISSUER_CERT_LOCALLY`

O emissor do certificado não é conhecido. Este é o caso se o emissor não estiver incluído na lista de certificados confiáveis.

`DEPTH_ZERO_SELF_SIGNED_CERT`

O certificado passado é autoassinado e o mesmo certificado não pode ser encontrado na lista de certificados confiáveis.

`SELF_SIGNED_CERT_IN_CHAIN`

O emissor do certificado não é conhecido. Este é o caso se o emissor não estiver incluído na lista de certificados confiáveis.

`CERT_CHAIN_TOO_LONG`

O comprimento da cadeia de certificados é maior que a profundidade máxima.

`UNABLE_TO_GET_CRL`

A CRL referenciada pelo certificado não pôde ser encontrada.

`UNABLE_TO_VERIFY_LEAF_SIGNATURE`

Nenhuma assinatura pôde ser verificada porque a cadeia contém apenas um certificado e não é autoassinado.

`CERT_UNTRUSTED`

A autoridade de certificação (CA) raiz não está marcada como confiável para o propósito especificado.

Erros de Extensão Básica

`INVALID_CA`

Um certificado CA é inválido. Ou não é uma CA ou suas extensões não são consistentes com o propósito fornecido.

`PATH_LENGTH_EXCEEDED`

O parâmetro pathlength basicConstraints foi excedido.

`HOSTNAME_MISMATCH`

O certificado não corresponde ao nome fornecido.

Erros de Uso e Política

`INVALID_PURPOSE`

O certificado fornecido não pode ser usado para o propósito especificado.

`CERT_REJECTED`

A CA raiz está marcada para rejeitar o propósito especificado.

Erros de Formatação

`CERT_SIGNATURE_FAILURE`

A assinatura do certificado é inválida.

`CRL_SIGNATURE_FAILURE`

A assinatura da lista de revogação de certificados (CRL) é inválida.

`ERROR_IN_CERT_NOT_BEFORE_FIELD`

O campo notBefore do certificado contém um tempo inválido.

`ERROR_IN_CERT_NOT_AFTER_FIELD`

O campo notAfter do certificado contém um tempo inválido.

`ERROR_IN_CRL_LAST_UPDATE_FIELD`

O campo lastUpdate da CRL contém um tempo inválido.

`ERROR_IN_CRL_NEXT_UPDATE_FIELD`

O campo nextUpdate da CRL contém um tempo inválido.

`UNABLE_TO_DECRYPT_CERT_SIGNATURE`

A assinatura do certificado não pôde ser descriptografada. Isso significa que o valor real da assinatura não pôde ser determinado, em vez de não corresponder ao valor esperado; isso só é significativo para chaves RSA.

`UNABLE_TO_DECRYPT_CRL_SIGNATURE`

A assinatura da lista de revogação de certificados (CRL) não pôde ser descriptografada: isso significa que o valor real da assinatura não pôde ser determinado, em vez de não corresponder ao valor esperado.

`UNABLE_TO_DECODE_ISSUER_PUBLIC_KEY`

A chave pública no SubjectPublicKeyInfo do certificado não pôde ser lida.

Outros Erros do OpenSSL

`OUT_OF_MEM`

Ocorreu um erro ao tentar alocar memória. Isso nunca deveria acontecer.

Erros ​

Propagação e interceptação de erros ​

Classe: Error ​

new Error(message[, options]) ​

Error.captureStackTrace(targetObject[, constructorOpt]) ​

Error.stackTraceLimit ​

error.cause ​

error.code ​

error.message ​

error.stack ​

Classe: AssertionError ​

Classe: RangeError ​

Classe: ReferenceError ​

Classe: SyntaxError ​

Classe: SystemError ​

error.address ​

error.code ​

error.dest ​

error.errno ​

error.info ​

error.message ​

error.path ​

error.port ​

error.syscall ​

Erros comuns do sistema ​

Classe: TypeError ​

Exceções vs. erros ​

Erros OpenSSL ​

error.opensslErrorStack ​

error.function ​

error.library ​

error.reason ​

Códigos de erro do 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 ​

Erros

Propagação e interceptação de erros

Classe: `Error`

`new Error(message[, options])`

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

`Error.stackTraceLimit`

`error.cause`

`error.code`

`error.message`

`error.stack`

Classe: `AssertionError`

Classe: `RangeError`

Classe: `ReferenceError`

Classe: `SyntaxError`

Classe: `SystemError`

`error.address`

`error.code`

`error.dest`

`error.errno`

`error.info`

`error.message`

`error.path`

`error.port`

`error.syscall`

Erros comuns do sistema

Classe: `TypeError`

Exceções vs. erros

Erros OpenSSL

`error.opensslErrorStack`

`error.function`

`error.library`

`error.reason`

Códigos de erro do 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`