src: disable V8 external memory reasonable size check

Project: nodejs/node | Language: C++, JavaScript | Concepts: memory-management, error-handling, configuration-management | Difficulty: mid
Link: https://github.com/nodejs/node/pull/65589

The problem

Node.js processes could be forcefully terminated by V8 when allocating a large buffer that increases external memory by more than 32 GB in one step. This is due to V8's --external-memory-max-reasonable-size flag, which is intended as a Chromium safety check but is too restrictive for Node.js. Instead of a fatal error, Node.js should handle such cases gracefully (e.g., by throwing a RangeError).

Why it's non-trivial

A naive fix might simply remove or override the flag, but this could break cases where a user explicitly sets their own limit via command-line arguments. The solution must ensure the default is disabled only if the user hasn't already provided a value, and must handle both dashed and underscored flag spellings accepted by V8.

The approach

1. Check for user-supplied flags before setting a default

The code inspects the list of V8 arguments to see if the user has already set the flag (in either spelling):

+  if (std::ranges::none_of(v8_args, [](const std::string& arg) {
+        return arg.starts_with("--external-memory-max-reasonable-size") ||
+               arg.starts_with("--external_memory_max_reasonable_size");
+      })) {
+    v8_args.emplace_back("--external-memory-max-reasonable-size=0");
+  }

This block checks if neither --external-memory-max-reasonable-size nor --external_memory_max_reasonable_size is present. If not, it appends a flag to disable the check by setting the value to 0. This ensures that user-supplied values always take precedence.

2. Add a test to verify correct behavior

A new test file ensures the flag is honored when set by the user:

+for (const flag of [
+  '--external-memory-max-reasonable-size=1',
+  '--external_memory_max_reasonable_size=1',
+]) {
+  const child = spawnSync(process.execPath, [
+    flag, '-e', 'new Float64Array(150_000_000)',
+  ]);
+
+  assert.notStrictEqual(
+    child.status,
+    0,
+    `${flag} was not honored, the child exited cleanly`,
+  );
+  assert.match(child.stderr.toString(), /kMaxReasonableBytes/);
+}

This test spawns a child process with a 1 GB external memory limit and tries to allocate more than that. It asserts that the process fails (as expected) and that the error message matches the fatal V8 check, confirming that explicit user flags are still respected.

From the review thread

No notable review discussion on this PR.

Takeaways

When overriding default configuration for a dependency, always check for and respect explicit user-supplied values.
Defensive checks (like memory limits) in dependencies may not be appropriate for all consumers; consider the context and intended use of your application.
When supporting multiple forms of input (e.g., dashed vs. underscored flags), ensure your code handles all accepted variants to avoid surprising behavior.