Erros

Aplicativos em execução no Node.js geralmente apresentarão quatro categorias de erros:

Erros padrão do JavaScript, como <EvalError>, <SyntaxError>, <RangeError>, <ReferenceError>, <TypeError> e <URIError>.
Erros do sistema acionados por restrições do sistema operacional subjacente, como tentar abrir um arquivo que não existe ou tentar enviar dados por um soquete 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. Elas são normalmente acionadas pelo módulo node:assert.

Todos os erros de JavaScript e do sistema acionados pelo Node.js herdam ou são instâncias da 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 oferece suporte a vários mecanismos para propagar e manipular erros que ocorrem enquanto um aplicativo está em execução. Como esses erros são relatados e manipulados 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 de JavaScript throw. Eles 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 lançará uma exceção que deve ser manipulada ou o processo do Node.js será encerrado imediatamente.

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

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

Alguns métodos assíncronos retornam um <Promise>, você deve sempre levar em consideração que ele pode ser rejeitado. Consulte a flag --unhandled-rejections para saber como o processo reagirá a uma rejeição de promessa não tratada.
A maioria dos métodos assíncronos que aceitam uma função callback aceitará 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, ocorrerá 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 pequeno número de métodos normalmente assíncronos na API do Node.js ainda pode usar o mecanismo throw para lançar exceções que devem ser tratadas usando try…catch. Não há uma lista abrangente de tais métodos; 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 emissores de eventos, que representam uma série de operações assíncronas ao longo do tempo (em oposição a 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 detectada 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('Isso irá travar'))
})

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

Os desenvolvedores devem consultar a documentação de cada método para determinar exatamente como os erros acionados 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. 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 é gerada chamando String(message). Se a opção cause for fornecida, ela é 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 estendem-se apenas até (a) o início da execução de código síncrono, ou (b) o número de quadros fornecidos 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 // Similar 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 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 sã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 para um valor não numérico ou para 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. Ela é usada ao capturar um erro e lançar um novo com uma mensagem ou código diferente, a fim de ainda ter acesso ao erro original.

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

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

const cause = new Error('O servidor HTTP remoto respondeu com um status 500')
const symptom = new Error('A mensagem falhou ao enviar', { cause })

console.log(symptom)
// Imprime:
//   Error: A mensagem falhou ao enviar
//       at REPL2:1:17
//       at Script.runInThisContext (node:vm:130:12)
//       ... 7 linhas correspondentes ao rastreamento de pilha da causa ...
//       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. Consulte códigos de erro do Node.js para obter detalhes sobre códigos específicos.

`error.message`

<string>

A propriedade error.message é a descrição em string do erro, conforme definido pela chamada de 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 depois que o objeto Error é criado 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)
// Imprime: 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 será capaz de encontrar um nome adequado. Se o V8 não conseguir determinar um nome para a função, apenas as informações de localização serão exibidas para esse quadro. Caso contrário, o nome da função determinado será exibido com as 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, por sua vez, 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()
// lançará:
//   /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 lentamente 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 do loop de evento atual.

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"

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

Classe: `ReferenceError`

Estende: <errors.Error>

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

Enquanto o código do cliente pode gerar e propagar esses erros, na prática, somente 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, instâncias de ReferenceError indicam um bug no código ou suas dependências.

Classe: `SyntaxError`

Estende: <errors.Error>

Indica que um programa não é JavaScript válido. Esses erros podem ser gerados e propagados somente como resultado da avaliação de código. A avaliação de 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.
}

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>

O Node.js gera erros de sistema quando exceções ocorrem dentro de 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 em 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 <Objeto> 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 do 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 do sistema frequentemente 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 maneira proibida por suas permissões de acesso a arquivos.
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 de tentar se 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 da conexão no socket remoto devido a um tempo limite ou reinicialização. Frequentemente encontrado nos 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 permitidos no sistema foi atingido e as solicitações de 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 (Arquivo ou diretório inexistente): Comumente levantado por operações fs para indicar que um componente do nome de 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 exigia 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 executar uma operação que requer privilégios elevados.
EPIPE (Canal quebrado): Uma gravação em um canal, socket ou FIFO para o qual não há nenhum processo para ler os dados. Frequentemente encontrado nas camadas net e http, indicando que o lado remoto do fluxo que está sendo gravado foi fechado.
ETIMEDOUT (Tempo limite da operação excedido): Uma solicitação de conexão ou envio falhou porque a parte conectada não respondeu corretamente após um período de tempo. Geralmente encontrado por http ou net. Muitas vezes, um sinal de que um socket.end() não foi chamado corretamente.

Classe: `TypeError`

Estende <errors.Error>

Indica que um argumento fornecido não é de um tipo permitido. Por exemplo, passar uma função para um parâmetro que espera uma string seria 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 argumentos.

Exceções vs. erros

Uma exceção JavaScript é um valor que é lançado como resultado de uma operação inválida ou como alvo de uma declaração throw. Embora não seja obrigatório que esses valores sejam instâncias de Error ou classes que herdem de Error, todas as exceções lançadas pelo Node.js ou pelo runtime 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 do OpenSSL

Erros originados 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 dar contexto sobre de onde na biblioteca OpenSSL um erro se origina.

`error.function`

A função OpenSSL onde o erro se origina.

`error.library`

A biblioteca OpenSSL onde 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ão.

`ERR_AMBIGUOUS_ARGUMENT`

Um argumento de função está sendo usado de uma maneira que sugere que a assinatura da função pode ser mal interpretada. 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 foi 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 deveria ocorrer. Estes são levantados tipicamente pelo módulo node:assert.

`ERR_ASYNC_CALLBACK`

Foi feita uma tentativa de registrar algo que não é uma função como um callback 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 fluxo 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 fluxo Brotli.

`ERR_BUFFER_CONTEXT_NOT_AVAILABLE`

Foi feita uma tentativa de criar uma instância Buffer do Node.js a partir de código de addon ou incorporador, enquanto em um Contexto do mecanismo 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 quando o método retornar.

Ao encontrar este erro, uma possível alternativa para criar uma instância 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`

Foi feita uma tentativa de criar um Buffer maior do 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 MessagePort em um estado fechado, geralmente depois que .close() foi chamado.

`ERR_CONSOLE_WRITABLE_STREAM`

Console foi instanciado sem o fluxo stdout, ou Console tem um fluxo 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 um erro ocorre (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, por meio 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 engine 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 scrypt. Não é possível com os binários de lançamento oficiais, mas pode acontecer com construções personalizadas, incluindo construções 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 cifrador 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

Uma tentativa de invocar uma operação criptográfica não suportada foi feita.

`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 expirou aguardando que o host/porta necessários ficassem 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 addons 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 configurar o servidor DNS.

`ERR_DOMAIN_CALLBACK_NOT_AVAILABLE`

O módulo node:domain não era utilizável, pois não pôde 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 da 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 para a API TextDecoder() eram inválidos de acordo com a codificação fornecida.

`ERR_ENCODING_NOT_SUPPORTED`

A codificação fornecida para a 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 é feita uma tentativa de 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 falso.

`ERR_FEATURE_UNAVAILABLE_ON_PLATFORM`

Adicionado em: v14.0.0

Foi feita uma tentativa de cópia 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 leitura de 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 payload.

`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 fluxos HTTP/2 não podem ser abertos depois que o Http2Session recebeu um quadro GOAWAY do par conectado.

`ERR_HTTP2_HEADERS_AFTER_RESPOND`

Um cabeçalho adicional foi especificado após o início de uma resposta HTTP/2.

`ERR_HTTP2_HEADERS_SENT`

Foi feita uma tentativa de envio de 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 de 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. Os códigos de status informacional devem ser um inteiro entre 100 e 199 (inclusive).

`ERR_HTTP2_INVALID_ORIGIN`

Os frames HTTP/2 ORIGIN exigem uma origem válida.

`ERR_HTTP2_INVALID_PACKED_SETTINGS_LENGTH`

As 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 pseudocabeçalhos HTTP/2 válidos (:status, :path, :authority, :scheme e :method) podem ser usados.

`ERR_HTTP2_INVALID_SESSION`

Uma ação foi realizada 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 realizada em um stream que já havia sido destruído.

`ERR_HTTP2_MAX_PENDING_SETTINGS_ACK`

Sempre que um frame HTTP/2 SETTINGS é enviado para 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 frames 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 stream push de dentro de um stream push. Streams 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 uma Http2Session.

`ERR_HTTP2_ORIGIN_LENGTH`

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

`ERR_HTTP2_OUT_OF_STREAMS`

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

`ERR_HTTP2_PAYLOAD_FORBIDDEN`

Uma carga útil de mensagem foi especificada para um código de resposta HTTP para o qual uma carga útil é proibida.

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

Uma tentativa foi feita para criar um fluxo push, que foi desabilitado pelo cliente.

`ERR_HTTP2_SEND_FILE`

Uma tentativa foi feita para usar a API Http2Stream.prototype.responseWithFile() para enviar um diretório.

`ERR_HTTP2_SEND_FILE_NOSEEK`

Uma tentativa foi feita para usar a API Http2Stream.prototype.responseWithFile() para enviar algo que não fosse 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`

Uma tentativa foi feita para conectar um objeto Http2Session a um net.Socket ou tls.TLSSocket que já havia sido vinculado a outro objeto Http2Session.

`ERR_HTTP2_SOCKET_UNBOUND`

Uma tentativa foi feita para usar a propriedade socket de um Http2Session que já foi fechada.

`ERR_HTTP2_STATUS_101`

O uso do código de status informativo 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 para o par conectado.

`ERR_HTTP2_STREAM_ERROR`

Um código de erro diferente de zero foi especificado em um quadro 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 quadros de protocolo HTTP/2 inválidos aceitáveis enviados pelo peer, conforme especificado através da opção maxSessionInvalidFrames, foi excedido.

`ERR_HTTP2_TRAILERS_ALREADY_SENT`

Os cabeçalhos de rastro 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 for definida para o Http2Stream.

`ERR_HTTP2_UNSUPPORTED_PROTOCOL`

http2.connect() recebeu um URL que usa qualquer protocolo diferente de 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`

Foi feita uma tentativa de 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 toda a solicitação 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`

Foi feita uma tentativa de 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 inspector 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 conexão quando o inspector já estava conectado.

`ERR_INSPECTOR_CLOSED`

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

`ERR_INSPECTOR_COMMAND`

Ocorreu um erro ao emitir um comando por meio 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 inspector 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 worker.

`ERR_INTERNAL_ASSERTION`

Havia um bug no Node.js ou um uso incorreto dos 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 do tipo errado 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 realizada em um Buffer, mas seu tamanho não era compatível com a operação.

`ERR_INVALID_CHAR`

Caracteres inválidos foram detectados em 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`

Uma tentativa foi feita para enviar um "handle" não suportado por meio de 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 não era válido.

`ERR_INVALID_MODULE_SPECIFIER`

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

`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 na análise.

`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 do 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 promessa.

`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 pode já ter sido destruído ou pode estar executando 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 iterable fornecido ao WHATWG URLSearchParams constructor não representava uma tupla [name, value] – 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 sintaxe TypeScript que requer transformação com remoção de tipo.

`ERR_INVALID_URI`

Uma URI inválida foi passada.

`ERR_INVALID_URL`

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

`ERR_INVALID_URL_SCHEME`

Foi feita uma tentativa de usar uma URL de um esquema (protocolo) incompatível para um propósito específico. Ele é usado apenas no suporte à API WHATWG URL 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`

Foi feita uma tentativa de usar um canal de comunicação IPC que já estava fechado.

`ERR_IPC_DISCONNECTED`

Foi feita uma tentativa de desconectar um canal de comunicação IPC que já estava desconectado. Consulte a documentação do módulo child_process para obter mais informações.

`ERR_IPC_ONE_PIPE`

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

`ERR_IPC_SYNC_FORK`

Foi feita uma tentativa de abrir um canal de comunicação IPC com um processo Node.js sincronizado. 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 hook de 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 um MessagePort não pôde ser desserializada no vm Context 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 obrigatório de uma API Node.js não foi passado. Isso é usado apenas para conformidade estrita 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 cumprida ou rejeitada, mas não ambas ao mesmo tempo. A última 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 do que o comprimento do 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 do 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 undefined do JavaScript.

`ERR_NON_CONTEXT_AWARE_DISABLED`

Um addon nativo não ciente do contexto 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 criar um snapshot de inicialização V8, mesmo que o Node.js não esteja criando 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 uma aplicação de executável único.

`ERR_NOT_SUPPORTED_IN_SNAPSHOT`

Foi feita uma tentativa de executar operações que não são suportadas ao criar 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 a criptografia OpenSSL.

`ERR_NO_ICU`

Foi feita uma tentativa de usar recursos que exigem ICU, mas o Node.js não foi compilado com suporte a 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 package.json "imports" não define o mapeamento do especificador de pacote interno fornecido.

`ERR_PACKAGE_PATH_NOT_EXPORTED`

O campo package.json "exports" 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 por meio da resolução de pacotes, a menos que se use uma URL absoluta.

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

`ERR_PERFORMANCE_MEASURE_INVALID_OPTIONS`

Estável: 1 Estabilidade: 1 - Experimental

Ao tentar require() um Módulo ES, uma aresta 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 de um módulo CommonJS, e deve ser feita de forma preguiçosa 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 declarado obsoleto, já que 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`

A execução do script expirou, possivelmente devido a erros 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 de 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 de Server HTTP, HTTPS e HTTP/2.

`ERR_SINGLE_EXECUTABLE_APPLICATION_ASSET_NOT_FOUND`

Adicionado em: v21.7.0, v20.12.0

Uma chave foi passada para APIs de aplicativo executável único 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 de API que esperava uma porta >= 0 e < 65536 recebeu um valor inválido.

`ERR_SOCKET_BAD_TYPE`

Uma função de API que esperava 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 em 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 Subrecurso, mas não pôde ser analisada. Verifique o formato dos atributos de integridade consultando a especificação de Integridade de Subrecurso.

`ERR_STREAM_ALREADY_FINISHED`

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

`ERR_STREAM_CANNOT_PIPE`

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

`ERR_STREAM_DESTROYED`

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

`ERR_STREAM_NULL_VALUES`

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

`ERR_STREAM_PREMATURE_CLOSE`

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

`ERR_STREAM_PUSH_AFTER_EOF`

Foi feita uma tentativa de chamar stream.push() depois que um null (EOF) foi enviado ao fluxo.

`ERR_STREAM_UNABLE_TO_PIPE`

Foi feita uma tentativa de redirecionar para um fluxo fechado ou destruído em um pipeline.

`ERR_STREAM_UNSHIFT_AFTER_END_EVENT`

Foi feita uma tentativa de chamar stream.unshift() depois que o evento 'end' foi emitido.

`ERR_STREAM_WRAP`

Impede um aborto se um decodificador de string foi definido no Socket ou se o decodificador estiver 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() depois que stream.end() foi 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`

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

`ERR_TAP_LEXER_ERROR`

Um erro que representa um estado de lexer com falha.

`ERR_TAP_PARSER_ERROR`

Um erro que representa um estado de parser com falha. Informações adicionais sobre o token que causou o erro estão disponíveis por meio da propriedade cause.

`ERR_TAP_VALIDATION_ERROR`

Este erro representa uma validação TAP com falha.

`ERR_TEST_FAILURE`

Este erro representa um teste com falha. Informações adicionais sobre a falha estão disponíveis por meio 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 incluírem ALPNProtocols e ALPNCallback. Essas 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. Os objetos de certificado produzidos pelo próprio Node.js sempre cumprem as regras de codificação e nunca causarão esse erro.

`ERR_TLS_CERT_ALTNAME_INVALID`

Ao usar TLS, o nome do host/IP do peer 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 chaves 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 recomendável usar 2048 bits ou mais para maior segurança.

`ERR_TLS_HANDSHAKE_TIMEOUT`

Um handshake TLS/SSL expirou. Neste 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 de forma segura. 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 a 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`

Foi feita uma tentativa de 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`

Foi feita uma tentativa de emitir a Indicação de Nome do Servidor de um socket do lado do servidor TLS, que é válida apenas a partir 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 stream Transform terminou enquanto ainda estava transformando.

`ERR_TRANSFORM_WITH_LENGTH_0`

Um stream Transform terminou com dados ainda no buffer de gravação.

`ERR_TTY_INIT_FAILED`

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

`ERR_UNAVAILABLE_DURING_EXIT`

A função foi chamada dentro de um manipulador process.on('exit') que não deveria ser chamado dentro de um 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 não deve ser normalmente 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

Foi feita uma tentativa de 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

Foi feita uma tentativa de 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 referência ao próprio 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 'package-name' // 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 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`

[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, devido a 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`

Os 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 do linker é de um contexto diferente do módulo pai. Os 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

O Response que foi passado 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 foi encerrada 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 é compatível com 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 as extensões de um 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	Mudanças
v11.4.0, v10.15.0	O tamanho máximo do cabeçalho em `http_parser` foi definido para 8 KiB.

Foram recebidos dados de cabeçalho HTTP em excesso. Para proteção contra clientes maliciosos ou mal configurados, se mais de maxHeaderSize de dados de cabeçalho HTTP forem recebidos, a análise HTTP será abortada sem que um objeto de solicitaçã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	Mudanças
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 na transferList para essa chamada. Geralmente, 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

Quando não há 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 valor dado está fora da faixa aceita.

`ERR_VM_MODULE_LINKING_ERRORED`

Adicionado em: v10.0.0

Removido em: v18.1.0, v16.17.0

A função do vinculador 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 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 do 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 pesquisado 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 ele não é autoassinado.

`CERT_UNTRUSTED`

A autoridade de certificação (CA) raiz não está marcada como confiável para a finalidade especificada.

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 a finalidade fornecida.

`PATH_LENGTH_EXCEEDED`

O parâmetro pathlength de 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 certificado (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, e não que não corresponde ao valor esperado, isso só é significativo para chaves RSA.

`UNABLE_TO_DECRYPT_CRL_SIGNATURE`

A assinatura da lista de revogação de certificado (CRL) não pôde ser descriptografada: isso significa que o valor real da assinatura não pôde ser determinado, e não que não corresponde 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 do 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 do 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`