[`suite()`]: #suitename-options-fn

[`test()`]: #testname-options-fn

[code coverage]: #collecting-code-coverage

[configuration files]: cli.md#--experimental-config-filepath---experimental-config-file

[describe options]: #describename-options-fn

[it options]: #testname-options-fn

[module customization hooks]: module.md#customization-hooks

.It Fl -experimental-addon-modules

Enable experimental addon module support.

.It Fl -experimental-config-file , Fl -experimental-config-file Ns = Ns Ar config , Fl -experimental-default-config-file

If present, Node.js will look for a configuration file at the specified path.

If the path is not specified, Node.js will look for a \fBnode.config.json\fR file

in the current working directory.

To specify a custom path, use the \fB--experimental-config-file=\fR\fBpath\fR form.

The space-separated \fB--experimental-config-file path\fR form is not supported.

Node.js will read the configuration file and apply the settings. The

configuration file should be a JSON file with the following structure. \fBvX.Y.Z\fR

in the \fB$schema\fR must be replaced with the version of Node.js you are using.

.Bd -literal

{

"$schema": "https://nodejs.org/dist/vX.Y.Z/docs/node-config-schema.json",

"nodeOptions": {

"import": [

"amaro/strip"

],

"watch-path": "src",

"watch-preserve-output": true

},

"testRunner": {

"test-isolation": "process"

},

"watch": {

"watch-preserve-output": true

}

}

.Ed

The configuration file supports namespace-specific options:

.Bl -bullet

.It

The \fBnodeOptions\fR field contains CLI flags that are allowed in \fBNODE_OPTIONS\fR.

.It

Namespace fields like \fBtestRunner\fR contain configuration specific to that subsystem.

.El

No-op flags are not supported.

Not all V8 flags are currently supported.

It is possible to use the official JSON schema

to validate the configuration file, which may vary depending on the Node.js version.

Each key in the configuration file corresponds to a flag that can be passed

as a command-line argument. The value of the key is the value that would be

passed to the flag.

For example, the configuration file above is equivalent to

the following command-line arguments:

.Bd -literal

node --import amaro/strip --watch-path=src --watch-preserve-output --test-isolation=process

.Ed

The priority in configuration is as follows:

.Bl -bullet

.It

NODE_OPTIONS and command-line options

.It

Dotenv NODE_OPTIONS

.It

Configuration file

.El

Values in the configuration file will not override the values in the environment

variables, command-line options, or the \fBNODE_OPTIONS\fR env file parsed by the

\fB--env-file\fR flag.

Keys cannot be duplicated within the same or different namespaces.

The configuration parser will throw an error if the configuration file contains

unknown keys or keys that cannot be used in a namespace.

Node.js will not sanitize or perform validation on the user-provided configuration,

so \fBNEVER\fR use untrusted configuration files.

.It Fl -experimental-default-config-file

This flag is an alias for \fB--experimental-config-file\fR without an argument.

If present, Node.js will look for a

\fBnode.config.json\fR file in the current working directory and load it as a

configuration file.

.It Fl -experimental-import-meta-resolve

Enable experimental ES modules support for import.meta.resolve().

const {

ArrayPrototypeForEach,

ArrayPrototypeJoin,

ArrayPrototypeMap,

ArrayPrototypePush,

}

continue;

}

if (arg === '--experimental-config-file' ||

StringPrototypeStartsWith(arg, '--experimental-config-file=')) {

continue;

}

if (arg === '--experimental-default-config-file') {

function initializeConfigFileSupport() {

if (getOptionValue('--experimental-config-file')) {

emitExperimentalWarning('--experimental-config-file');

}

function filterExecArgv(arg, i, arr) {

return !ArrayPrototypeIncludes(kFilterArgs, arg) &&

!ArrayPrototypeSome(kFilterArgValues, (p) => {

return arg === p ||

StringPrototypeStartsWith(arg, `${p}=`) ||

(p !== '--experimental-config-file' && i > 0 && arr[i - 1] === p);

});

function getRunArgs(path, { forceExit,

}

std::string node_options_from_config;

auto config_path = per_process::config_reader.GetDataFromArgs(argv);

if (per_process::config_reader.HasInvalidDefaultConfigFileArgument()) {

errors->push_back("--experimental-default-config-file does not take an "

"argument");

return ExitCode::kInvalidCommandLineArgument;

}

if (config_path) {

switch (per_process::config_reader.ParseConfig(*config_path)) {

case ParseResult::Valid:

break;

case ParseResult::InvalidContent:

errors->push_back(std::string(*config_path) + ": invalid content");

break;

case ParseResult::FileError:

errors->push_back(std::string(*config_path) + ": not found");

break;

default:

UNREACHABLE();

#include "debug_utils-inl.h"

#include "simdjson.h"

namespace node {

constexpr std::string_view kConfigFileFlag = "--experimental-config-file";

constexpr std::string_view kDefaultConfigFileFlag =

"--experimental-default-config-file";

constexpr std::string_view kDefaultConfigFileName = "node.config.json";

inline bool HasEqualsPrefix(std::string_view arg, std::string_view flag) {

return arg.size() > flag.size() && arg.starts_with(flag) &&

arg[flag.size()] == '=';

}

std::optional<std::string_view> ConfigReader::GetDataFromArgs(

std::vector<std::string>* args) {

std::optional<std::string_view> result;

invalid_default_config_file_argument_ = false;

for (size_t i = 0; i < args->size(); ++i) {

std::string& arg = (*args)[i];

if (arg == kConfigFileFlag) {

// --experimental-config-file

arg = std::string(kConfigFileFlag) + "=" +

std::string(kDefaultConfigFileName);

result = kDefaultConfigFileName;

} else if (HasEqualsPrefix(arg, kConfigFileFlag)) {

// --experimental-config-file=path

std::string_view path =

std::string_view(arg).substr(kConfigFileFlag.size() + 1);

if (!path.empty()) {

result = path;

}

} else if (arg == kDefaultConfigFileFlag) {

// --experimental-default-config-file

arg = std::string(kConfigFileFlag) + "=" +

std::string(kDefaultConfigFileName);

result = kDefaultConfigFileName;

} else if (HasEqualsPrefix(arg, kDefaultConfigFileFlag)) {

invalid_default_config_file_argument_ = true;

}

}

return result;

}

bool ConfigReader::HasInvalidDefaultConfigFileArgument() const {

return invalid_default_config_file_argument_;

}

ParseResult ConfigReader::ProcessOptionValue(

ParseResult ParseConfig(const std::string_view& config_path);

std::optional<std::string_view> GetDataFromArgs(

std::vector<std::string>* args);

bool HasInvalidDefaultConfigFileArgument() const;

std::string GetNodeOptions();

const std::vector<std::string>& GetNamespaceFlags() const;

std::vector<std::string> node_options_;

std::vector<std::string> namespace_options_;

bool invalid_default_config_file_argument_ = false;

// Cache for fast lookup of environment options

std::unordered_map<std::string, options_parser::OptionMappingDetails>

&EnvironmentOptions::optional_env_file);

Implies("--env-file-if-exists", "[has_env_file_string]");

AddOption("--experimental-config-file",

"set config file path",

&EnvironmentOptions::experimental_config_file_path,

kDisallowedInEnvvar);

AddAlias("--experimental-default-config-file", "--experimental-config-file");

AddOption("--test",

"launch test runner on startup",

&EnvironmentOptions::test_runner,