fix(ext/node): implement node:v8 heap APIs (#32483)

Implements `v8.getHeapSpaceStatistics()`,
`v8.getHeapCodeStatistics()`, `v8.getHeapSnapshot()`, and
`v8.writeHeapSnapshot()` from the `node:v8` module

Enabled node compat tests: `test-heapdump.js`,
`test-v8-getheapsnapshot-twice.js`, `test-v8-stats.js`

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: bartlomieju

Cargo.lock

@@ -98,7 +98,7 @@ deno_task_shell = "=0.29.0"
 deno_terminal = "=0.2.3"
 deno_unsync = { version = "0.4.4", default-features = false }
 deno_whoami = "0.1.0"
-v8 = { version = "146.2.0", default-features = false }
+v8 = { version = "146.3.0", default-features = false }
 
 denokv_proto = "0.13.0"
 denokv_remote = "0.13.0"

Cargo.toml

@@ -213,6 +213,10 @@ deno_core::extension!(deno_node,
     ops::winerror::op_node_sys_to_uv_error,
     ops::v8::op_v8_cached_data_version_tag,
     ops::v8::op_v8_get_heap_statistics,
+    ops::v8::op_v8_number_of_heap_spaces,
+    ops::v8::op_v8_update_heap_space_statistics,
+    ops::v8::op_v8_get_heap_code_statistics,
+    ops::v8::op_v8_take_heap_snapshot,
     ops::v8::op_v8_get_wire_format_version,
     ops::v8::op_v8_new_deserializer,
     ops::v8::op_v8_new_serializer,

ext/node/lib.rs

@@ -39,6 +39,51 @@ pub fn op_v8_get_heap_statistics(
   buffer[13] = stats.external_memory() as f64;
 }
 
+#[op2(fast)]
+#[smi]
+pub fn op_v8_number_of_heap_spaces(scope: &mut v8::PinScope<'_, '_>) -> u32 {
+  scope.number_of_heap_spaces() as u32
+}
+
+#[op2]
+#[string]
+pub fn op_v8_update_heap_space_statistics(
+  scope: &mut v8::PinScope<'_, '_>,
+  #[buffer] buffer: &mut [f64],
+  #[smi] space_index: u32,
+) -> Option<String> {
+  let stats = scope.get_heap_space_statistics(space_index as usize)?;
+  buffer[0] = stats.space_size() as f64;
+  buffer[1] = stats.space_used_size() as f64;
+  buffer[2] = stats.space_available_size() as f64;
+  buffer[3] = stats.physical_space_size() as f64;
+  Some(stats.space_name().to_string_lossy().into_owned())
+}
+
+#[op2]
+#[buffer]
+pub fn op_v8_take_heap_snapshot(scope: &mut v8::PinScope<'_, '_>) -> Vec<u8> {
+  let mut buf = Vec::new();
+  scope.take_heap_snapshot(|chunk| {
+    buf.extend_from_slice(chunk);
+    true
+  });
+  buf
+}
+
+#[op2(fast)]
+pub fn op_v8_get_heap_code_statistics(
+  scope: &mut v8::PinScope<'_, '_>,
+  #[buffer] buffer: &mut [f64],
+) {
+  if let Some(stats) = scope.get_heap_code_and_metadata_statistics() {
+    buffer[0] = stats.code_and_metadata_size() as f64;
+    buffer[1] = stats.bytecode_and_metadata_size() as f64;
+    buffer[2] = stats.external_script_source_size() as f64;
+    buffer[3] = stats.cpu_profiler_metadata_size() as f64;
+  }
+}
+
 pub struct Serializer<'a> {
   inner: v8::ValueSerializer<'a>,
 }

ext/node/ops/v8.rs

@@ -10,10 +10,12 @@ import { primordials } from "ext:core/mod.js";
 const { ObjectPrototypeToString, SymbolSpecies } = primordials;
 import {
   op_v8_cached_data_version_tag,
+  op_v8_get_heap_code_statistics,
   op_v8_get_heap_statistics,
   op_v8_get_wire_format_version,
   op_v8_new_deserializer,
   op_v8_new_serializer,
+  op_v8_number_of_heap_spaces,
   op_v8_read_double,
   op_v8_read_header,
   op_v8_read_raw_bytes,
@@ -22,8 +24,10 @@ import {
   op_v8_read_value,
   op_v8_release_buffer,
   op_v8_set_treat_array_buffer_views_as_host_objects,
+  op_v8_take_heap_snapshot,
   op_v8_transfer_array_buffer,
   op_v8_transfer_array_buffer_de,
+  op_v8_update_heap_space_statistics,
   op_v8_write_double,
   op_v8_write_header,
   op_v8_write_raw_bytes,
@@ -33,21 +37,54 @@ import {
 } from "ext:core/ops";
 
 import { Buffer } from "node:buffer";
+import { writeFileSync } from "node:fs";
+import { Readable } from "node:stream";
 
 import { notImplemented } from "ext:deno_node/_utils.ts";
 import { isArrayBufferView } from "ext:deno_node/internal/util/types.ts";
+import { getValidatedPath } from "ext:deno_node/internal/fs/utils.mjs";
+import { validateObject } from "ext:deno_node/internal/validators.mjs";
 
 export function cachedDataVersionTag() {
   return op_v8_cached_data_version_tag();
 }
+const heapCodeStatisticsBuffer = new Float64Array(4);
+
 export function getHeapCodeStatistics() {
-  notImplemented("v8.getHeapCodeStatistics");
+  op_v8_get_heap_code_statistics(heapCodeStatisticsBuffer);
+  return {
+    code_and_metadata_size: heapCodeStatisticsBuffer[0],
+    bytecode_and_metadata_size: heapCodeStatisticsBuffer[1],
+    external_script_source_size: heapCodeStatisticsBuffer[2],
+    cpu_profiler_metadata_size: heapCodeStatisticsBuffer[3],
+  };
 }
-export function getHeapSnapshot() {
-  notImplemented("v8.getHeapSnapshot");
+export function getHeapSnapshot(options?: Record<string, unknown>) {
+  if (options !== undefined) {
+    validateObject(options, "options");
+  }
+  const data = op_v8_take_heap_snapshot();
+  return Readable.from(Buffer.from(data));
 }
+const heapSpaceStatisticsBuffer = new Float64Array(4);
+
 export function getHeapSpaceStatistics() {
-  notImplemented("v8.getHeapSpaceStatistics");
+  const numberOfHeapSpaces = op_v8_number_of_heap_spaces();
+  const heapSpaceStatistics = new Array(numberOfHeapSpaces);
+  for (let i = 0; i < numberOfHeapSpaces; i++) {
+    const spaceName = op_v8_update_heap_space_statistics(
+      heapSpaceStatisticsBuffer,
+      i,
+    );
+    heapSpaceStatistics[i] = {
+      space_name: spaceName,
+      space_size: heapSpaceStatisticsBuffer[0],
+      space_used_size: heapSpaceStatisticsBuffer[1],
+      space_available_size: heapSpaceStatisticsBuffer[2],
+      physical_space_size: heapSpaceStatisticsBuffer[3],
+    };
+  }
+  return heapSpaceStatistics;
 }
 
 const buffer = new Float64Array(14);
@@ -89,9 +126,39 @@ export function stopCoverage() {
 export function takeCoverage() {
   notImplemented("v8.takeCoverage");
 }
-export function writeHeapSnapshot() {
-  notImplemented("v8.writeHeapSnapshot");
+
+let heapSnapshotCounter = 0;
+
+export function writeHeapSnapshot(
+  filename?: string,
+  options?: Record<string, unknown>,
+) {
+  if (filename !== undefined) {
+    filename = getValidatedPath(filename) as string;
+  } else {
+    const now = new Date();
+    const year = now.getFullYear();
+    const month = String(now.getMonth() + 1).padStart(2, "0");
+    const day = String(now.getDate()).padStart(2, "0");
+    const hours = String(now.getHours()).padStart(2, "0");
+    const minutes = String(now.getMinutes()).padStart(2, "0");
+    const seconds = String(now.getSeconds()).padStart(2, "0");
+    const pid = globalThis.process?.pid ?? 0;
+    const thread = 0;
+    const seq = ++heapSnapshotCounter;
+    filename =
+      `Heap.${year}${month}${day}.${hours}${minutes}${seconds}.${pid}.${thread}.${
+        String(seq).padStart(3, "0")
+      }.heapsnapshot`;
+  }
+  if (options !== undefined) {
+    validateObject(options, "options");
+  }
+  const data = op_v8_take_heap_snapshot();
+  writeFileSync(filename, data);
+  return filename;
 }
+
 // deno-lint-ignore no-explicit-any
 export function serialize(value: any) {
   const ser = new DefaultSerializer();

ext/node/polyfills/v8.ts

@@ -1503,7 +1503,9 @@
     "parallel/test-uv-binding-constant.js": {},
     "parallel/test-v8-deserialize-buffer.js": {},
     "parallel/test-v8-flag-pool-size-0.js": {},
+    "parallel/test-v8-getheapsnapshot-twice.js": {},
     "parallel/test-v8-global-setter.js": {},
+    "parallel/test-v8-stats.js": {},
     "parallel/test-vm-access-process-env.js": {},
     "parallel/test-vm-api-handles-getter-errors.js": {},
     "parallel/test-vm-attributes-property-not-on-sandbox.js": {},
@@ -1774,6 +1776,9 @@
     // "sequential/test-diagnostic-dir-heap-prof.js": {},
     "sequential/test-fs-readdir-recursive.js": {},
     "sequential/test-fs-stat-sync-overflow.js": {},
+    "sequential/test-heapdump.js": {
+      "windows": false
+    },
     "sequential/test-http-server-keep-alive-timeout-slow-server.js": {},
     // TODO(bartlomieju): disabled during work on `node:inspector`, this test didn't actualy run before
     // "sequential/test-inspector-open-dispose.mjs": {},

tests/node_compat/config.jsonc

@@ -1,28 +1,22 @@
 // Copyright 2018-2026 the Deno authors. MIT license.
-import {
-  cachedDataVersionTag,
-  deserialize,
-  getHeapStatistics,
-  serialize,
-  setFlagsFromString,
-} from "node:v8";
-import { assertEquals } from "@std/assert";
+import * as v8 from "node:v8";
+import { assertEquals, assertThrows } from "@std/assert";
 
 // https://github.com/nodejs/node/blob/a2bbe5ff216bc28f8dac1c36a8750025a93c3827/test/parallel/test-v8-version-tag.js#L6
 Deno.test({
   name: "cachedDataVersionTag success",
   fn() {
-    const tag = cachedDataVersionTag();
+    const tag = v8.cachedDataVersionTag();
     assertEquals(typeof tag, "number");
-    assertEquals(cachedDataVersionTag(), tag);
+    assertEquals(v8.cachedDataVersionTag(), tag);
   },
 });
 
 // https://github.com/nodejs/node/blob/a2bbe5ff216bc28f8dac1c36a8750025a93c3827/test/parallel/test-v8-stats.js#L6
 Deno.test({
   name: "getHeapStatistics success",
   fn() {
-    const s = getHeapStatistics();
+    const s = v8.getHeapStatistics();
     const keys = [
       "does_zap_garbage",
       "external_memory",
@@ -52,15 +46,25 @@ Deno.test({
 Deno.test({
   name: "setFlagsFromString",
   fn() {
-    setFlagsFromString("--allow_natives_syntax");
+    v8.setFlagsFromString("--allow_natives_syntax");
   },
 });
 
 Deno.test({
   name: "serialize deserialize",
   fn() {
-    const s = serialize({ a: 1 });
-    const d = deserialize(s);
+    const s = v8.serialize({ a: 1 });
+    const d = v8.deserialize(s);
     assertEquals(d, { a: 1 });
   },
 });
+
+Deno.test({
+  name: "writeHeapSnapshot requires write permission",
+  permissions: { write: false },
+  fn() {
+    assertThrows(() => {
+      v8.writeHeapSnapshot("test.heapsnapshot");
+    }, Deno.errors.NotCapable);
+  },
+});