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

#if !NODE_USE_V8_PLATFORM && !HAVE_INSPECTOR

if (inspector_enabled) {

errors->push_back("Inspector is not available when Node is compiled "

"--without-v8-platform and --without-inspector.");

}

#endif

if (deprecated_debug) {

errors->push_back("[DEP0062]: `node --debug` and `node --debug-brk` "

"are invalid. Please use `node --inspect` and "

"`node --inspect-brk` instead.");

}

using std::operator""sv;

auto entries = std::views::split(inspect_publish_uid_string, ","sv);

inspect_publish_uid.console = false;

inspect_publish_uid.http = false;

for (const auto& entry : entries) {

std::string_view destination(entry.data(), entry.size());

if (destination == "stderr"sv) {

inspect_publish_uid.console = true;

} else if (destination == "http"sv) {

inspect_publish_uid.http = true;

} else {

errors->emplace_back("--inspect-publish-uid destination can be "

"stderr or http");

}

}

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

#if HAVE_OPENSSL

if (use_openssl_ca && use_bundled_ca) {

errors->push_back("either --use-openssl-ca or --use-bundled-ca can be "

"used, not both");

}

// Any value less than 2 disables use of the secure heap.

#ifndef V8_ENABLE_SANDBOX

// The secure heap is not supported when V8_ENABLE_SANDBOX is enabled.

if (secure_heap >= 2) {

if ((secure_heap & (secure_heap - 1)) != 0)

errors->push_back("--secure-heap must be a power of 2");

secure_heap_min =

std::min({

secure_heap,

secure_heap_min,

static_cast<int64_t>(std::numeric_limits<int>::max())});

secure_heap_min = std::max(static_cast<int64_t>(2), secure_heap_min);

if ((secure_heap_min & (secure_heap_min - 1)) != 0)

errors->push_back("--secure-heap-min must be a power of 2");

}

#endif // V8_ENABLE_SANDBOX

#endif // HAVE_OPENSSL

if (!build_sea.empty()) {

#if defined(DISABLE_SINGLE_EXECUTABLE_APPLICATION)

errors->push_back("Single executable application is disabled.\n");

#elif !defined(HAVE_LIEF)

errors->push_back(

"Node.js must be built with LIEF to build support --build-sea.\n");

#endif // !defined(HAVE_LIEF)

}

if (use_largepages != "off" &&

use_largepages != "on" &&

use_largepages != "silent") {

errors->push_back("invalid value for --use-largepages");

}

per_isolate->CheckOptions(errors, argv);

std::vector<std::string>* errors,

std::string* max_old_space_size_percentage) {

std::string original_input_for_error = *max_old_space_size_percentage;

// Parse the percentage value

char* end_ptr;

double percentage =

std::strtod(max_old_space_size_percentage->c_str(), &end_ptr);

// Validate the percentage value

if (*end_ptr != '\0' || percentage <= 0.0 || percentage > 100.0) {

errors->push_back("--max-old-space-size-percentage must be greater "

"than 0 and up to 100. Got: " +

original_input_for_error);

return;

}

// Get available memory in bytes

#ifdef V8_COMPRESS_POINTERS

// When pointer compression is enabled, V8 uses a 4 GiB heap limit.

// We'll use the smaller of that or the total system memory as

// reported by uv.

uint64_t total_memory =

std::min(uv_get_total_memory(), kMaxPointerCompressionHeap); // 4 GiB

#else

uint64_t total_memory = uv_get_total_memory();

#endif

uint64_t constrained_memory = uv_get_constrained_memory();

// Use constrained memory if available, otherwise use total memory

// This logic correctly handles the documented guarantees.

// Use uint64_t for the result to prevent data loss on 32-bit systems.

uint64_t available_memory =

(constrained_memory > 0 && constrained_memory != UINT64_MAX)

? constrained_memory

: total_memory;

if (available_memory == 0) {

errors->push_back("the available memory can not be calculated");

return;

}

// Convert to MB and calculate the percentage

uint64_t memory_mb = available_memory / (1024 * 1024);

uint64_t calculated_mb = static_cast<size_t>(memory_mb * percentage / 100.0);

// Convert back to string

max_old_space_size = std::to_string(calculated_mb);

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

if (!max_old_space_size_percentage.empty()) {

HandleMaxOldSpaceSizePercentage(errors, &max_old_space_size_percentage);

}

per_env->CheckOptions(errors, argv);

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

if (!input_type.empty()) {

if (input_type != "commonjs" && input_type != "module" &&

input_type != "commonjs-typescript" &&

input_type != "module-typescript") {

errors->push_back(

"--input-type must be \"module\","

"\"commonjs\", \"module-typescript\" or \"commonjs-typescript\"");

}

}

if (syntax_check_only && has_eval_string) {

errors->push_back("either --check or --eval can be used, not both");

}

if (!unhandled_rejections.empty() &&

unhandled_rejections != "warn-with-error-code" &&

unhandled_rejections != "throw" &&

unhandled_rejections != "strict" &&

unhandled_rejections != "warn" &&

unhandled_rejections != "none") {

errors->push_back("invalid value for --unhandled-rejections");

}

if (tls_min_v1_3 && tls_max_v1_2) {

errors->push_back("either --tls-min-v1.3 or --tls-max-v1.2 can be "

"used, not both");

}

#if HAVE_OPENSSL

if (use_system_ca && per_process::cli_options->use_openssl_ca) {

errors->push_back("either --use-openssl-ca or --use-system-ca can be "

"used, not both");

}

#endif // HAVE_OPENSSL

if (heap_snapshot_near_heap_limit < 0) {

errors->push_back("--heapsnapshot-near-heap-limit must not be negative");

}

if (!trace_require_module.empty() && trace_require_module != "all" &&

trace_require_module != "no-node-modules") {

errors->push_back("invalid value for --trace-require-module");

}

if (test_runner) {

if (test_isolation == "none") {

debug_options_.allow_attaching_debugger = true;

} else {

if (test_isolation != "process") {

errors->push_back("invalid value for --test-isolation");

}

#ifndef ALLOW_ATTACHING_DEBUGGER_IN_TEST_RUNNER

debug_options_.allow_attaching_debugger = false;

#endif

}

if (syntax_check_only) {

errors->push_back("either --test or --check can be used, not both");

}

if (has_eval_string) {

errors->push_back("either --test or --eval can be used, not both");

}

if (force_repl) {

errors->push_back("either --test or --interactive can be used, not both");

}

if (watch_mode_paths.size() > 0) {

errors->push_back(

"--watch-path cannot be used in combination with --test");

}

}

if (watch_mode) {

if (syntax_check_only) {

errors->push_back("either --watch or --check can be used, not both");

} else if (has_eval_string) {

errors->push_back("either --watch or --eval can be used, not both");

} else if (force_repl) {

errors->push_back("either --watch or --interactive "

"can be used, not both");

} else if (test_runner_force_exit) {

errors->push_back("either --watch or --test-force-exit "

"can be used, not both");

} else if (!test_runner && watch_mode_paths.empty() && argv->size() < 1) {

errors->push_back("--watch requires specifying a file");

}

#ifndef ALLOW_ATTACHING_DEBUGGER_IN_WATCH_MODE

debug_options_.allow_attaching_debugger = false;

#endif

}

#if HAVE_INSPECTOR

if (!cpu_prof) {

if (!cpu_prof_name.empty()) {

errors->push_back("--cpu-prof-name must be used with --cpu-prof");

}

if (!cpu_prof_dir.empty()) {

errors->push_back("--cpu-prof-dir must be used with --cpu-prof");

}

// We can't catch the case where the value passed is the default value,

// then the option just becomes a noop which is fine.

if (cpu_prof_interval != kDefaultCpuProfInterval) {

errors->push_back("--cpu-prof-interval must be used with --cpu-prof");

}

}

if (cpu_prof && cpu_prof_dir.empty() && !diagnostic_dir.empty()) {

cpu_prof_dir = diagnostic_dir;

}

if (!heap_prof) {

if (!heap_prof_name.empty()) {

errors->push_back("--heap-prof-name must be used with --heap-prof");

}

if (!heap_prof_dir.empty()) {

errors->push_back("--heap-prof-dir must be used with --heap-prof");

}

// We can't catch the case where the value passed is the default value,

// then the option just becomes a noop which is fine.

if (heap_prof_interval != kDefaultHeapProfInterval) {

errors->push_back("--heap-prof-interval must be used with --heap-prof");

}

}

if (heap_prof && heap_prof_dir.empty() && !diagnostic_dir.empty()) {

heap_prof_dir = diagnostic_dir;

}

debug_options_.CheckOptions(errors, argv);

#endif // HAVE_INSPECTOR

Local<Context> context,

Local<Object> object,

const std::string& option_name,

const OptionMappingDetails& option_details) {

std::string type;

switch (static_cast<int>(option_details.type)) {

case 0: // No-op

case 1: // V8 flags

break; // V8 and NoOp flags are not supported

case 2:

type = "boolean";

break;

case 3: // integer

case 4: // unsigned integer

case 6: // host port

type = "number";

break;

case 5: // string

type = "string";

break;

case 7: // string array

type = "array";

break;

default:

UNREACHABLE();

}

if (type.empty()) {

return true; // Skip this entry but continue processing

}

Local<String> option_key;

if (!String::NewFromUtf8(isolate,

option_name.data(),

v8::NewStringType::kNormal,

option_name.size())

.ToLocal(&option_key)) {

return true; // Skip this entry but continue processing

}

Local<String> type_value;

if (!String::NewFromUtf8(

isolate, type.data(), v8::NewStringType::kNormal, type.size())

.ToLocal(&type_value)) {

return true; // Skip this entry but continue processing

}

Local<String> help_text;

if (!String::NewFromUtf8(isolate,

option_details.help_text.data(),

v8::NewStringType::kNormal,

option_details.help_text.size())

.ToLocal(&help_text)) {

return true; // Skip this entry but continue processing

}

// Create an object with type and help_text properties

Local<Value> null_value = Null(isolate);

constexpr size_t kOptionInfoLength = 2;

std::array<Local<Name>, kOptionInfoLength> names = {

String::NewFromUtf8Literal(isolate, "type"),

String::NewFromUtf8Literal(isolate, "description")};

std::array<Local<Value>, kOptionInfoLength> values = {type_value, help_text};

Local<Object> option_info = Object::New(

isolate, null_value, names.data(), values.data(), kOptionInfoLength);

if (object->Set(context, option_key, option_info).IsNothing()) {

return false; // Error occurred, stop processing

}

return true;

public:

EnvironmentOptionsParser();

explicit EnvironmentOptionsParser(const DebugOptionsParser& dop)

: EnvironmentOptionsParser() {

Insert(dop, &EnvironmentOptions::get_debug_options);

}

public:

PerIsolateOptionsParser() = delete;

explicit PerIsolateOptionsParser(const EnvironmentOptionsParser& eop);

public:

PerProcessOptionsParser() = delete;

explicit PerProcessOptionsParser(const PerIsolateOptionsParser& iop);

StringVector* const args, StringVector* const exec_args,

StringVector* const v8_args,

DebugOptions* const options,

OptionEnvvarSettings required_env_settings, StringVector* const errors) {

_dop_instance.Parse(

args, exec_args, v8_args, options, required_env_settings, errors);

StringVector* const args, StringVector* const exec_args,

StringVector* const v8_args,

PerIsolateOptions* const options,

OptionEnvvarSettings required_env_settings, StringVector* const errors) {

_piop_instance.Parse(

args, exec_args, v8_args, options, required_env_settings, errors);

StringVector* const args, StringVector* const exec_args,

StringVector* const v8_args,

PerProcessOptions* const options,

OptionEnvvarSettings required_env_settings, StringVector* const errors) {

_ppop_instance.Parse(

args, exec_args, v8_args, options, required_env_settings, errors);

AddOption("--inspect-port",

"set host:port for inspector",

&DebugOptions::host_port,

kAllowedInEnvvar);

AddAlias("--debug-port", "--inspect-port");

AddOption("--inspect",

"activate inspector on host:port (default: 127.0.0.1:9229)",

&DebugOptions::inspector_enabled,

kAllowedInEnvvar);

AddAlias("--inspect=", { "--inspect-port", "--inspect" });

AddOption("--debug", "", &DebugOptions::deprecated_debug);

AddAlias("--debug=", "--debug");

AddOption("--debug-brk", "", &DebugOptions::deprecated_debug);

AddAlias("--debug-brk=", "--debug-brk");

AddOption("--inspect-brk",

"activate inspector on host:port and break at start of user script",

&DebugOptions::break_first_line,

kAllowedInEnvvar);

Implies("--inspect-brk", "--inspect");

AddAlias("--inspect-brk=", { "--inspect-port", "--inspect-brk" });

AddOption("--inspect-brk-node", "", &DebugOptions::break_node_first_line);

Implies("--inspect-brk-node", "--inspect");

AddAlias("--inspect-brk-node=", { "--inspect-port", "--inspect-brk-node" });

AddOption(

"--inspect-wait",

"activate inspector on host:port and wait for debugger to be attached",

&DebugOptions::inspect_wait,

kAllowedInEnvvar);

Implies("--inspect-wait", "--inspect");

AddAlias("--inspect-wait=", {"--inspect-port", "--inspect-wait"});

AddOption("--inspect-publish-uid",

"comma separated list of destinations for inspector uid"

"(default: stderr,http)",

&DebugOptions::inspect_publish_uid_string,

kAllowedInEnvvar);

AddOption("--conditions",

"additional user conditions for conditional exports and imports",

&EnvironmentOptions::conditions,

kAllowedInEnvvar);

AddAlias("-C", "--conditions");

AddOption("--experimental-detect-module",

"when ambiguous modules fail to evaluate because they contain "

"ES module syntax, try again to evaluate them as ES modules",

&EnvironmentOptions::detect_module,

kAllowedInEnvvar,

true);

AddOption("--experimental-print-required-tla",

"Print pending top-level await. If --require-module "

"is true, evaluate asynchronous graphs loaded by `require()` but "

"do not run the microtasks, in order to to find and print "

"top-level await in the graph",

&EnvironmentOptions::print_required_tla,

kAllowedInEnvvar);

AddOption("--require-module",

"Allow loading synchronous ES Modules in require().",

&EnvironmentOptions::require_module,

kAllowedInEnvvar,

true);

AddOption("--experimental-require-module",

"Legacy alias for --require-module",

&EnvironmentOptions::require_module,

kAllowedInEnvvar,

true);

Implies("--experimental-require-module", "--require-module");

AddOption("--diagnostic-dir",

"set dir for all output files"

" (default: current working directory)",

&EnvironmentOptions::diagnostic_dir,

kAllowedInEnvvar);

AddOption("--disable-sigusr1",

"Disable inspector thread to be listening for SIGUSR1 signal",

&EnvironmentOptions::disable_sigusr1,

kAllowedInEnvvar,

false);

AddOption("--dns-result-order",

"set default value of verbatim in dns.lookup. Options are "

"'ipv4first' (IPv4 addresses are placed before IPv6 addresses) "

"'ipv6first' (IPv6 addresses are placed before IPv4 addresses) "

"'verbatim' (addresses are in the order the DNS resolver "

"returned)",

&EnvironmentOptions::dns_result_order,

kAllowedInEnvvar);

AddOption("--network-family-autoselection",

"Disable network address family autodetection algorithm",

&EnvironmentOptions::network_family_autoselection,

kAllowedInEnvvar,

true);

AddOption("--network-family-autoselection-attempt-timeout",

"Sets the default value for the network family autoselection "

"attempt timeout.",

&EnvironmentOptions::network_family_autoselection_attempt_timeout,

kAllowedInEnvvar);

AddAlias("--enable-network-family-autoselection",

"--network-family-autoselection");

AddOption("--enable-source-maps",

"Source Map V3 support for stack traces",

&EnvironmentOptions::enable_source_maps,

kAllowedInEnvvar);

AddOption("--entry-url",

"Treat the entrypoint as a URL",

&EnvironmentOptions::entry_is_url,

kAllowedInEnvvar);

AddOption("--experimental-addon-modules",

"experimental import support for addons",

&EnvironmentOptions::experimental_addon_modules,

kAllowedInEnvvar);

AddOption("--experimental-abortcontroller", "", NoOp{}, kAllowedInEnvvar);

AddOption("--experimental-eventsource",

"experimental EventSource API",

&EnvironmentOptions::experimental_eventsource,

kAllowedInEnvvar,

false);

AddOption("--experimental-fetch", "", NoOp{}, kAllowedInEnvvar);

AddOption("--experimental-websocket",

"experimental WebSocket API",

&EnvironmentOptions::experimental_websocket,

kAllowedInEnvvar,

true);

AddOption("--experimental-global-customevent", "", NoOp{}, kAllowedInEnvvar);

AddOption("--experimental-sqlite",

"experimental node:sqlite module",

&EnvironmentOptions::experimental_sqlite,

kAllowedInEnvvar,

true);

AddOption("--experimental-stream-iter",

"experimental iterable streams API (node:stream/iter)",

&EnvironmentOptions::experimental_stream_iter,

kAllowedInEnvvar);

AddOption("--experimental-quic",

#ifndef OPENSSL_NO_QUIC

"experimental QUIC support",

&EnvironmentOptions::experimental_quic,

#else

"" /* undocumented when no-op */,

NoOp{},

#endif

kAllowedInEnvvar);

AddOption("--experimental-webstorage",

"experimental Web Storage API",

&EnvironmentOptions::webstorage,

kAllowedInEnvvar,

HAVE_SQLITE);

AddAlias("--webstorage", "--experimental-webstorage");

AddOption("--localstorage-file",

"file used to persist localStorage data",

&EnvironmentOptions::localstorage_file,

kAllowedInEnvvar);

AddOption("--experimental-global-navigator",

"expose experimental Navigator API on the global scope",

&EnvironmentOptions::experimental_global_navigator,

kAllowedInEnvvar,

true);

AddOption("--experimental-global-webcrypto", "", NoOp{}, kAllowedInEnvvar);

AddOption("--experimental-json-modules", "", NoOp{}, kAllowedInEnvvar);

AddOption("--experimental-loader",

"use the specified module as a custom loader",

&EnvironmentOptions::userland_loaders,

kAllowedInEnvvar);

AddAlias("--loader", "--experimental-loader");

AddOption("--experimental-modules", "", NoOp{}, kAllowedInEnvvar);

AddOption("--experimental-wasm-modules", "", NoOp{}, kAllowedInEnvvar);

AddOption("--experimental-import-meta-resolve",

"experimental ES Module import.meta.resolve() parentURL support",

&EnvironmentOptions::experimental_import_meta_resolve,

kAllowedInEnvvar);

AddOption("--permission",

"enable the permission system",

&EnvironmentOptions::permission,

kAllowedInEnvvar,

false,

OptionNamespaces::kPermissionNamespace);

AddOption("--permission-audit",

"enable audit only for the permission system",

&EnvironmentOptions::permission_audit,

kAllowedInEnvvar,

false);

AddOption("--allow-fs-read",

"allow permissions to read the filesystem",

&EnvironmentOptions::allow_fs_read,

kAllowedInEnvvar,

OptionNamespaces::kPermissionNamespace);

AddOption("--allow-fs-write",

"allow permissions to write in the filesystem",

&EnvironmentOptions::allow_fs_write,

kAllowedInEnvvar,

OptionNamespaces::kPermissionNamespace);

AddOption("--allow-addons",

"allow use of addons when any permissions are set",

&EnvironmentOptions::allow_addons,

kAllowedInEnvvar,

false,

OptionNamespaces::kPermissionNamespace);

AddOption("--allow-child-process",

"allow use of child process when any permissions are set",

&EnvironmentOptions::allow_child_process,

kAllowedInEnvvar,

false,

OptionNamespaces::kPermissionNamespace);

AddOption("--allow-inspector",

"allow use of inspector when any permissions are set",

&EnvironmentOptions::allow_inspector,

kAllowedInEnvvar,

false,

OptionNamespaces::kPermissionNamespace);

AddOption("--allow-net",

"allow use of network when any permissions are set",

&EnvironmentOptions::allow_net,

kAllowedInEnvvar,

false,

OptionNamespaces::kPermissionNamespace);

AddOption("--allow-wasi",

"allow wasi when any permissions are set",

&EnvironmentOptions::allow_wasi,

kAllowedInEnvvar,

false,

OptionNamespaces::kPermissionNamespace);

AddOption("--allow-worker",

"allow worker threads when any permissions are set",

&EnvironmentOptions::allow_worker_threads,

kAllowedInEnvvar,

false,

OptionNamespaces::kPermissionNamespace);

AddOption("--experimental-repl-await",

"experimental await keyword support in REPL",

&EnvironmentOptions::experimental_repl_await,

kAllowedInEnvvar,

true);

AddOption("--experimental-vm-modules",

"experimental ES Module support in vm module",

&EnvironmentOptions::experimental_vm_modules,

kAllowedInEnvvar);

AddOption("--experimental-worker", "", NoOp{}, kAllowedInEnvvar);

AddOption("--experimental-report", "", NoOp{}, kAllowedInEnvvar);

AddOption(

"--experimental-wasi-unstable-preview1", "", NoOp{}, kAllowedInEnvvar);

AddOption("--expose-gc", "expose gc extension", V8Option{}, kAllowedInEnvvar);

AddOption("--async-context-frame",

"Improve AsyncLocalStorage performance with AsyncContextFrame",

&EnvironmentOptions::async_context_frame,

kAllowedInEnvvar,

true);

AddOption("--expose-internals", "", &EnvironmentOptions::expose_internals);

AddOption("--frozen-intrinsics",

"experimental frozen intrinsics support",

&EnvironmentOptions::frozen_intrinsics,

kAllowedInEnvvar);

AddOption("--heapsnapshot-signal",

"Generate heap snapshot on specified signal",

&EnvironmentOptions::heap_snapshot_signal,

kAllowedInEnvvar);

AddOption("--heapsnapshot-near-heap-limit",

"Generate heap snapshots whenever V8 is approaching "

"the heap limit. No more than the specified number of "

"heap snapshots will be generated.",

&EnvironmentOptions::heap_snapshot_near_heap_limit,

kAllowedInEnvvar);

AddOption("--http-parser", "", NoOp{}, kAllowedInEnvvar);

AddOption("--insecure-http-parser",

"use an insecure HTTP parser that accepts invalid HTTP headers",

&EnvironmentOptions::insecure_http_parser,

kAllowedInEnvvar);

AddOption("--input-type",

"set module type for string input",

&EnvironmentOptions::input_type,

kAllowedInEnvvar);

AddOption(

"--experimental-specifier-resolution", "", NoOp{}, kAllowedInEnvvar);

AddAlias("--es-module-specifier-resolution",

"--experimental-specifier-resolution");

AddOption("--deprecation",

"silence deprecation warnings",

&EnvironmentOptions::deprecation,

kAllowedInEnvvar,

true);

AddOption("--force-async-hooks-checks",

"disable checks for async_hooks",

&EnvironmentOptions::force_async_hooks_checks,

kAllowedInEnvvar,

true);

AddOption(

"--force-node-api-uncaught-exceptions-policy",

"enforces 'uncaughtException' event on Node API asynchronous callbacks",

&EnvironmentOptions::force_node_api_uncaught_exceptions_policy,

kAllowedInEnvvar,

false);

AddOption("--addons",

"disable loading native addons",

&EnvironmentOptions::allow_native_addons,

kAllowedInEnvvar,

true);

AddOption("--global-search-paths",

"disable global module search paths",

&EnvironmentOptions::global_search_paths,

kAllowedInEnvvar,

true);

AddOption("--warnings",

"silence all process warnings",

&EnvironmentOptions::warnings,

kAllowedInEnvvar,

true);

AddOption("--disable-warning",

"silence specific process warnings",

&EnvironmentOptions::disable_warnings,

kAllowedInEnvvar);

AddOption("--force-context-aware",

"disable loading non-context-aware addons",

&EnvironmentOptions::force_context_aware,

kAllowedInEnvvar);

AddOption("--pending-deprecation",

"emit pending deprecation warnings",

&EnvironmentOptions::pending_deprecation,

kAllowedInEnvvar);

AddOption("--use-env-proxy",

"parse proxy settings from HTTP_PROXY/HTTPS_PROXY/NO_PROXY"

"environment variables and apply the setting in global HTTP/HTTPS "

"clients",

&EnvironmentOptions::use_env_proxy,

kAllowedInEnvvar);

AddOption("--preserve-symlinks",

"preserve symbolic links when resolving",

&EnvironmentOptions::preserve_symlinks,

kAllowedInEnvvar);

AddOption("--preserve-symlinks-main",

"preserve symbolic links when resolving the main module",

&EnvironmentOptions::preserve_symlinks_main,

kAllowedInEnvvar);

AddOption("--prof",

"Generate V8 profiler output.",

V8Option{});

AddOption("--prof-process",

"process V8 profiler output generated using --prof",

&EnvironmentOptions::prof_process);

// Options after --prof-process are passed through to the prof processor.

AddAlias("--prof-process", {"--prof-process", "--"});

#if HAVE_INSPECTOR

AddOption("--cpu-prof",

"Start the V8 CPU profiler on start up, and write the CPU profile "

"to disk before exit. If --cpu-prof-dir is not specified, write "

"the profile to the current working directory.",

&EnvironmentOptions::cpu_prof,

kAllowedInEnvvar);

AddOption("--cpu-prof-name",

"specified file name of the V8 CPU profile generated with "

"--cpu-prof",

&EnvironmentOptions::cpu_prof_name,

kAllowedInEnvvar);

AddOption("--cpu-prof-interval",

"specified sampling interval in microseconds for the V8 CPU "

"profile generated with --cpu-prof. (default: 1000)",

&EnvironmentOptions::cpu_prof_interval,

kAllowedInEnvvar);

AddOption("--cpu-prof-dir",

"Directory where the V8 profiles generated by --cpu-prof will be "

"placed. Does not affect --prof.",

&EnvironmentOptions::cpu_prof_dir,

kAllowedInEnvvar);

AddOption("--experimental-network-inspection",

"experimental network inspection support",

&EnvironmentOptions::experimental_network_inspection);

AddOption("--experimental-storage-inspection",

"experimental storage inspection support",

&EnvironmentOptions::experimental_storage_inspection);

AddOption("--experimental-worker-inspection",

"experimental worker inspection support",

&EnvironmentOptions::experimental_worker_inspection);

AddOption("--experimental-inspector-network-resource",

"experimental load network resources via the inspector",

&EnvironmentOptions::experimental_inspector_network_resource);

AddOption(

"--heap-prof",

"Start the V8 heap profiler on start up, and write the heap profile "

"to disk before exit. If --heap-prof-dir is not specified, write "

"the profile to the current working directory.",

&EnvironmentOptions::heap_prof,

kAllowedInEnvvar);

AddOption("--heap-prof-name",

"specified file name of the V8 heap profile generated with "

"--heap-prof",

&EnvironmentOptions::heap_prof_name,

kAllowedInEnvvar);

AddOption("--heap-prof-dir",

"Directory where the V8 heap profiles generated by --heap-prof "

"will be placed.",

&EnvironmentOptions::heap_prof_dir,

kAllowedInEnvvar);

AddOption("--heap-prof-interval",

"specified sampling interval in bytes for the V8 heap "

"profile generated with --heap-prof. (default: 512 * 1024)",

&EnvironmentOptions::heap_prof_interval,

kAllowedInEnvvar);

#endif // HAVE_INSPECTOR

AddOption("--max-http-header-size",

"set the maximum size of HTTP headers (default: 16384 (16KB))",

&EnvironmentOptions::max_http_header_size,

kAllowedInEnvvar);

AddOption("--redirect-warnings",

"write warnings to file instead of stderr",

&EnvironmentOptions::redirect_warnings,

kAllowedInEnvvar);

AddOption(

"[has_env_file_string]", "", &EnvironmentOptions::has_env_file_string);

AddOption("--env-file",

"set environment variables from supplied file",

&EnvironmentOptions::env_file);

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

AddOption("--env-file-if-exists",

"set environment variables from supplied file",

&EnvironmentOptions::optional_env_file);

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

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

"set config file from supplied file",

&EnvironmentOptions::experimental_config_file_path);

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

"set config file from default config file",

&EnvironmentOptions::experimental_default_config_file);

AddOption("--test",

"launch test runner on startup",

&EnvironmentOptions::test_runner,

kDisallowedInEnvvar,

false,

OptionNamespaces::kTestRunnerNamespace);

AddOption("--test-concurrency",

"specify test runner concurrency",

&EnvironmentOptions::test_runner_concurrency,

kDisallowedInEnvvar,

OptionNamespaces::kTestRunnerNamespace);

AddOption("--test-force-exit",

"force test runner to exit upon completion",

&EnvironmentOptions::test_runner_force_exit,

kDisallowedInEnvvar,

false,

OptionNamespaces::kTestRunnerNamespace);

AddOption("--test-timeout",

"specify test runner timeout",

&EnvironmentOptions::test_runner_timeout,

kDisallowedInEnvvar,

OptionNamespaces::kTestRunnerNamespace);

AddOption("--test-update-snapshots",

"regenerate test snapshots",

&EnvironmentOptions::test_runner_update_snapshots,

kDisallowedInEnvvar,

false,

OptionNamespaces::kTestRunnerNamespace);

AddOption("--experimental-test-coverage",

"enable code coverage in the test runner",

&EnvironmentOptions::test_runner_coverage,

kDisallowedInEnvvar,

false,

OptionNamespaces::kTestRunnerNamespace);

AddOption("--test-coverage-branches",

"the branch coverage minimum threshold",

&EnvironmentOptions::test_coverage_branches,

kAllowedInEnvvar,

OptionNamespaces::kTestRunnerNamespace);

AddOption("--test-coverage-functions",

"the function coverage minimum threshold",

&EnvironmentOptions::test_coverage_functions,

kAllowedInEnvvar,

OptionNamespaces::kTestRunnerNamespace);

AddOption("--test-coverage-lines",

"the line coverage minimum threshold",

&EnvironmentOptions::test_coverage_lines,

kAllowedInEnvvar,

OptionNamespaces::kTestRunnerNamespace);

AddOption("--test-isolation",

"configures the type of test isolation used in the test runner",

&EnvironmentOptions::test_isolation,

kAllowedInEnvvar,

OptionNamespaces::kTestRunnerNamespace);

// TODO(cjihrig): Remove this alias in a semver major.

AddAlias("--experimental-test-isolation", "--test-isolation");

AddOption("--experimental-test-module-mocks",

"enable module mocking in the test runner",

&EnvironmentOptions::test_runner_module_mocks,

kDisallowedInEnvvar,

false,

OptionNamespaces::kTestRunnerNamespace);

AddOption("--experimental-test-snapshots",

"",

NoOp{},

kDisallowedInEnvvar,

OptionNamespaces::kTestRunnerNamespace);

AddOption("--test-name-pattern",

"run tests whose name matches this regular expression",

&EnvironmentOptions::test_name_pattern,

kAllowedInEnvvar,

OptionNamespaces::kTestRunnerNamespace);

AddOption("--test-reporter",

"report test output using the given reporter",

&EnvironmentOptions::test_reporter,

kAllowedInEnvvar,

OptionNamespaces::kTestRunnerNamespace);

AddOption("--test-reporter-destination",

"report given reporter to the given destination",

&EnvironmentOptions::test_reporter_destination,

kAllowedInEnvvar,

OptionNamespaces::kTestRunnerNamespace);

AddOption("--test-only",

"run tests with 'only' option set",

&EnvironmentOptions::test_only,

kAllowedInEnvvar,

false,

OptionNamespaces::kTestRunnerNamespace);

AddOption("--test-shard",

"run test at specific shard",

&EnvironmentOptions::test_shard,

kAllowedInEnvvar,

OptionNamespaces::kTestRunnerNamespace);

AddOption("--test-skip-pattern",

"run tests whose name do not match this regular expression",

&EnvironmentOptions::test_skip_pattern,

kAllowedInEnvvar,

OptionNamespaces::kTestRunnerNamespace);

AddOption("--test-coverage-include",

"include files in coverage report that match this glob pattern",

&EnvironmentOptions::coverage_include_pattern,

kAllowedInEnvvar,

OptionNamespaces::kTestRunnerNamespace);

AddOption("--test-coverage-exclude",

"exclude files from coverage report that match this glob pattern",

&EnvironmentOptions::coverage_exclude_pattern,

kAllowedInEnvvar,

OptionNamespaces::kTestRunnerNamespace);