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");

}

if (force_fips_crypto_policy != "provider" &&

force_fips_crypto_policy != "strict") {

errors->push_back(

"invalid value for --force-fips; expected 'provider' or 'strict'");

}

#if defined(OPENSSL_IS_BORINGSSL) || !OPENSSL_VERSION_PREREQ(3, 4)

if (enable_fips_indicator_events) {

errors->push_back(

"--enable-fips-indicator-events requires OpenSSL 3.4 or later");

}

if (force_fips_crypto && force_fips_crypto_policy == "strict") {

errors->push_back("--force-fips=strict requires OpenSSL 3.4 or later");

}

#endif

// 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");

}

// NOTE: `has_bench_options` is deliberately *not* validated against

// `experimental_bench` here; see CheckBenchOptions(), which callers invoke

// once every option source has been parsed.

if (bench_runner && test_runner) {

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

}

if (bench_runner) {

if (bench_isolation == "none") {

debug_options_.allow_attaching_debugger = true;

} else {

if (bench_isolation != "process") {

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

}

debug_options_.allow_attaching_debugger = false;

}

if (has_bench_samples && bench_samples == 0) {

errors->push_back("--bench-samples must be greater than 0");

}

if (syntax_check_only) {

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

}

if (has_eval_string) {

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

}

if (force_repl) {

errors->push_back(

"either --bench or --interactive can be used, not both");

}

if (watch_mode || !watch_mode_paths.empty()) {

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

}

}

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

std::vector<std::string>* errors) const {

if (has_bench_options && !experimental_bench) {

errors->push_back(

"--experimental-bench is required to use --bench or related options");

}

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)",

BOOL_FIELD(inspector_enabled),

kAllowedInEnvvar);

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

AddOption("--debug", "", BOOL_FIELD(deprecated_debug));

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

AddOption("--debug-brk", "", BOOL_FIELD(deprecated_debug));

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

AddOption("--inspect-brk",

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

BOOL_FIELD(break_first_line),

kAllowedInEnvvar);

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

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

AddOption("--inspect-brk-node", "", BOOL_FIELD(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",

BOOL_FIELD(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",

BOOL_FIELD(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 find and print "

"top-level await in the graph",

BOOL_FIELD(print_required_tla),

kAllowedInEnvvar);

AddOption("--require-module",

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

BOOL_FIELD(require_module),

kAllowedInEnvvar,

true);

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

"Legacy alias for --require-module",

BOOL_FIELD(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",

BOOL_FIELD(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",

BOOL_FIELD(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",

BOOL_FIELD(enable_source_maps),

kAllowedInEnvvar);

AddOption("--entry-url",

"Treat the entrypoint as a URL",

BOOL_FIELD(entry_is_url),

kAllowedInEnvvar);

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

"experimental import support for addons",

BOOL_FIELD(experimental_addon_modules),

kAllowedInEnvvar);

AddOption("--experimental-bench",

"experimental node:bench module and benchmark runner",

BOOL_FIELD(experimental_bench),

kAllowedInEnvvar);

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

AddOption("--experimental-eventsource",

"experimental EventSource API",

BOOL_FIELD(experimental_eventsource),

kAllowedInEnvvar,

false);

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

#if HAVE_FFI

AddOption("--experimental-ffi",

"experimental node:ffi module",

BOOL_FIELD(experimental_ffi),

kAllowedInEnvvar,

HAVE_FFI);

#endif // HAVE_FFI

AddOption("--experimental-web-worker",

"experimental Web Worker API",

BOOL_FIELD(experimental_web_worker),

kAllowedInEnvvar,

false);

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

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

AddOption("--experimental-sqlite",

"experimental node:sqlite module",

BOOL_FIELD(experimental_sqlite),

kAllowedInEnvvar,

HAVE_SQLITE);

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

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

BOOL_FIELD(experimental_stream_iter),

kAllowedInEnvvar);

AddOption("--experimental-dtls",

#if HAVE_DTLS

"experimental DTLS support",

BOOL_FIELD(experimental_dtls),

#else

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

NoOp{},

#endif

kAllowedInEnvvar);

AddOption("--experimental-vfs",

"experimental node:vfs module",

BOOL_FIELD(experimental_vfs),

kAllowedInEnvvar);

AddOption("--experimental-quic",

#ifndef OPENSSL_NO_QUIC

"experimental QUIC support",

BOOL_FIELD(experimental_quic),

#else

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

NoOp{},

#endif

kAllowedInEnvvar);

AddOption("--experimental-webstorage",

"experimental Web Storage API",

BOOL_FIELD(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",

BOOL_FIELD(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-text",

"experimental support for importing source as text with import "

"attributes",

BOOL_FIELD(experimental_import_text),

kAllowedInEnvvar);

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

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

BOOL_FIELD(experimental_import_meta_resolve),

kAllowedInEnvvar);

AddOption("--permission",

"enable the permission system",

BOOL_FIELD(permission),

kAllowedInEnvvar,

false,

OptionNamespaces::kPermissionNamespace);

AddOption("--permission-audit",

"enable audit only for the permission system",

BOOL_FIELD(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-fs-vfs",

"allow mounting a virtual file system when any permissions are set",

BOOL_FIELD(allow_fs_vfs),

kAllowedInEnvvar,

false,

OptionNamespaces::kPermissionNamespace);

AddOption("--allow-addons",

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

BOOL_FIELD(allow_addons),

kAllowedInEnvvar,

false,

OptionNamespaces::kPermissionNamespace);

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

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

BOOL_FIELD(allow_child_process),

kAllowedInEnvvar,

false,

OptionNamespaces::kPermissionNamespace);

#if HAVE_FFI

AddOption("--allow-ffi",

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

BOOL_FIELD(allow_ffi),

kAllowedInEnvvar,

false,

OptionNamespaces::kPermissionNamespace);

#endif // HAVE_FFI

AddOption("--allow-inspector",

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

BOOL_FIELD(allow_inspector),

kAllowedInEnvvar,

false,

OptionNamespaces::kPermissionNamespace);

AddOption("--allow-net",

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

BOOL_FIELD(allow_net),

kAllowedInEnvvar,

false,

OptionNamespaces::kPermissionNamespace);

AddOption("--allow-wasi",

"allow wasi when any permissions are set",

BOOL_FIELD(allow_wasi),

kAllowedInEnvvar,

false,

OptionNamespaces::kPermissionNamespace);

AddOption("--allow-worker",

"allow worker threads when any permissions are set",

BOOL_FIELD(allow_worker_threads),

kAllowedInEnvvar,

false,

OptionNamespaces::kPermissionNamespace);

AddOption("--allow-openssl-store",

"allow use of OpenSSL STORE loaders when any permissions are set",

BOOL_FIELD(allow_openssl_store),

kAllowedInEnvvar,

false,

OptionNamespaces::kPermissionNamespace);

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

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

"experimental ES Module support in vm module",

BOOL_FIELD(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",

BOOL_FIELD(async_context_frame),

kAllowedInEnvvar,

true);

AddOption("--expose-internals", "", BOOL_FIELD(expose_internals));

AddOption("--frozen-intrinsics",

"experimental frozen intrinsics support",

BOOL_FIELD(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",

BOOL_FIELD(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",

BOOL_FIELD(deprecation),

kAllowedInEnvvar,

true);

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

"disable checks for async_hooks",

BOOL_FIELD(force_async_hooks_checks),

kAllowedInEnvvar,

true);

AddOption(

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

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

BOOL_FIELD(force_node_api_uncaught_exceptions_policy),

kAllowedInEnvvar,

false);

AddOption("--addons",

"disable loading native addons",

BOOL_FIELD(allow_native_addons),

kAllowedInEnvvar,

true);

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

"disable global module search paths",

BOOL_FIELD(global_search_paths),

kAllowedInEnvvar,

true);

AddOption("--warnings",

"silence all process warnings",

BOOL_FIELD(warnings),

kAllowedInEnvvar,

true);

AddOption("--disable-warning",

"silence specific process warnings",

&EnvironmentOptions::disable_warnings,

kAllowedInEnvvar);

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

"disable loading non-context-aware addons",

BOOL_FIELD(force_context_aware),

kAllowedInEnvvar);

AddOption("--pending-deprecation",

"emit pending deprecation warnings",

BOOL_FIELD(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",

BOOL_FIELD(use_env_proxy),

kAllowedInEnvvar);

AddOption("--preserve-symlinks",

"preserve symbolic links when resolving",

BOOL_FIELD(preserve_symlinks),

kAllowedInEnvvar);

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

"preserve symbolic links when resolving the main module",

BOOL_FIELD(preserve_symlinks_main),

kAllowedInEnvvar);

AddOption("--prof",

"Generate V8 profiler output.",

V8Option{});

AddOption("--prof-process",

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

BOOL_FIELD(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.",

BOOL_FIELD(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",

BOOL_FIELD(experimental_network_inspection));

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

"experimental storage inspection support",

BOOL_FIELD(experimental_storage_inspection));

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

"experimental worker inspection support",

BOOL_FIELD(experimental_worker_inspection));

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

"experimental load network resources via the inspector",

BOOL_FIELD(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.",

BOOL_FIELD(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]", "", BOOL_FIELD(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 path",

&EnvironmentOptions::experimental_config_file_path,

kDisallowedInEnvvar);

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

AddOption("--experimental-package-map",