feat: expose individual ResourceConstraints setters and getters

Add bindings for the V8 ResourceConstraints API so that embedders can
set individual heap generation limits instead of only using the
high-level ConfigureDefaultsFromHeapSize helper.

New APIs on CreateParams:
- set_max_old_generation_size_in_bytes / max_old_generation_size_in_bytes
- set_max_young_generation_size_in_bytes / max_young_generation_size_in_bytes
- set_code_range_size_in_bytes / code_range_size_in_bytes
- set_stack_limit / stack_limit
- set_initial_old_generation_size_in_bytes / initial_old_generation_size_in_bytes
- set_initial_young_generation_size_in_bytes / initial_young_generation_size_in_bytes

This is needed by Deno to properly implement Node.js-compatible worker
thread resource limits (maxOldGenerationSizeMb, maxYoungGenerationSizeMb,
codeRangeSizeMb, stackSizeMb).

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: bartlomieju

src/binding.cc

@@ -432,6 +432,66 @@ void v8__ResourceConstraints__ConfigureDefaults(
   constraints->ConfigureDefaults(physical_memory, virtual_memory_limit);
 }
 
+size_t v8__ResourceConstraints__max_old_generation_size_in_bytes(
+    const v8::ResourceConstraints* constraints) {
+  return constraints->max_old_generation_size_in_bytes();
+}
+
+void v8__ResourceConstraints__set_max_old_generation_size_in_bytes(
+    v8::ResourceConstraints* constraints, size_t limit) {
+  constraints->set_max_old_generation_size_in_bytes(limit);
+}
+
+size_t v8__ResourceConstraints__max_young_generation_size_in_bytes(
+    const v8::ResourceConstraints* constraints) {
+  return constraints->max_young_generation_size_in_bytes();
+}
+
+void v8__ResourceConstraints__set_max_young_generation_size_in_bytes(
+    v8::ResourceConstraints* constraints, size_t limit) {
+  constraints->set_max_young_generation_size_in_bytes(limit);
+}
+
+size_t v8__ResourceConstraints__code_range_size_in_bytes(
+    const v8::ResourceConstraints* constraints) {
+  return constraints->code_range_size_in_bytes();
+}
+
+void v8__ResourceConstraints__set_code_range_size_in_bytes(
+    v8::ResourceConstraints* constraints, size_t limit) {
+  constraints->set_code_range_size_in_bytes(limit);
+}
+
+uint32_t* v8__ResourceConstraints__stack_limit(
+    const v8::ResourceConstraints* constraints) {
+  return constraints->stack_limit();
+}
+
+void v8__ResourceConstraints__set_stack_limit(
+    v8::ResourceConstraints* constraints, uint32_t* value) {
+  constraints->set_stack_limit(value);
+}
+
+size_t v8__ResourceConstraints__initial_old_generation_size_in_bytes(
+    const v8::ResourceConstraints* constraints) {
+  return constraints->initial_old_generation_size_in_bytes();
+}
+
+void v8__ResourceConstraints__set_initial_old_generation_size_in_bytes(
+    v8::ResourceConstraints* constraints, size_t initial_size) {
+  constraints->set_initial_old_generation_size_in_bytes(initial_size);
+}
+
+size_t v8__ResourceConstraints__initial_young_generation_size_in_bytes(
+    const v8::ResourceConstraints* constraints) {
+  return constraints->initial_young_generation_size_in_bytes();
+}
+
+void v8__ResourceConstraints__set_initial_young_generation_size_in_bytes(
+    v8::ResourceConstraints* constraints, size_t initial_size) {
+  constraints->set_initial_young_generation_size_in_bytes(initial_size);
+}
+
 void v8__HandleScope__CONSTRUCT(uninit_t<v8::HandleScope>* buf,
                                 v8::Isolate* isolate) {
   construct_in_place<v8::HandleScope>(buf, isolate);

src/isolate_create_params.rs

@@ -173,6 +173,113 @@ impl CreateParams {
     self
   }
 
+  /// Returns the maximum size of the old generation in bytes.
+  pub fn max_old_generation_size_in_bytes(&self) -> usize {
+    self.raw.constraints.max_old_generation_size_in_bytes()
+  }
+
+  /// Sets the maximum size of the old generation in bytes. When the old
+  /// generation approaches this limit, V8 will perform series of garbage
+  /// collections and invoke the NearHeapLimitCallback.
+  pub fn set_max_old_generation_size_in_bytes(
+    mut self,
+    limit: usize,
+  ) -> Self {
+    self
+      .raw
+      .constraints
+      .set_max_old_generation_size_in_bytes(limit);
+    self
+  }
+
+  /// Returns the maximum size of the young generation in bytes.
+  pub fn max_young_generation_size_in_bytes(&self) -> usize {
+    self.raw.constraints.max_young_generation_size_in_bytes()
+  }
+
+  /// Sets the maximum size of the young generation in bytes. The young
+  /// generation consists of two semi-spaces and a large object space. This
+  /// affects frequency of Scavenge garbage collections.
+  pub fn set_max_young_generation_size_in_bytes(
+    mut self,
+    limit: usize,
+  ) -> Self {
+    self
+      .raw
+      .constraints
+      .set_max_young_generation_size_in_bytes(limit);
+    self
+  }
+
+  /// Returns the code range size in bytes.
+  pub fn code_range_size_in_bytes(&self) -> usize {
+    self.raw.constraints.code_range_size_in_bytes()
+  }
+
+  /// Sets the amount of virtual memory reserved for generated code in bytes.
+  /// This is relevant for 64-bit architectures that rely on code range for
+  /// calls in code.
+  pub fn set_code_range_size_in_bytes(mut self, limit: usize) -> Self {
+    self.raw.constraints.set_code_range_size_in_bytes(limit);
+    self
+  }
+
+  /// Returns the stack limit (the address beyond which the VM's stack may
+  /// not grow), or null if not set.
+  pub fn stack_limit(&self) -> *mut u32 {
+    self.raw.constraints.stack_limit()
+  }
+
+  /// Sets the address beyond which the VM's stack may not grow.
+  ///
+  /// # Safety
+  ///
+  /// The caller must ensure that the pointer remains valid for the lifetime
+  /// of the isolate, and points to a valid stack boundary.
+  pub unsafe fn set_stack_limit(mut self, value: *mut u32) -> Self {
+    self.raw.constraints.set_stack_limit(value);
+    self
+  }
+
+  /// Returns the initial size of the old generation in bytes.
+  pub fn initial_old_generation_size_in_bytes(&self) -> usize {
+    self.raw.constraints.initial_old_generation_size_in_bytes()
+  }
+
+  /// Sets the initial size of the old generation in bytes. Setting the
+  /// initial size avoids ineffective garbage collections at startup if the
+  /// live set is large.
+  pub fn set_initial_old_generation_size_in_bytes(
+    mut self,
+    initial_size: usize,
+  ) -> Self {
+    self
+      .raw
+      .constraints
+      .set_initial_old_generation_size_in_bytes(initial_size);
+    self
+  }
+
+  /// Returns the initial size of the young generation in bytes.
+  pub fn initial_young_generation_size_in_bytes(&self) -> usize {
+    self
+      .raw
+      .constraints
+      .initial_young_generation_size_in_bytes()
+  }
+
+  /// Sets the initial size of the young generation in bytes.
+  pub fn set_initial_young_generation_size_in_bytes(
+    mut self,
+    initial_size: usize,
+  ) -> Self {
+    self
+      .raw
+      .constraints
+      .set_initial_young_generation_size_in_bytes(initial_size);
+    self
+  }
+
   /// A CppHeap used to construct the Isolate. V8 takes ownership of the
   /// CppHeap passed this way.
   pub fn cpp_heap(mut self, heap: UniqueRef<Heap>) -> Self {
@@ -267,6 +374,48 @@ pub(crate) mod raw {
       physical_memory: u64,
       virtual_memory_limit: u64,
     );
+    fn v8__ResourceConstraints__max_old_generation_size_in_bytes(
+      constraints: *const ResourceConstraints,
+    ) -> usize;
+    fn v8__ResourceConstraints__set_max_old_generation_size_in_bytes(
+      constraints: *mut ResourceConstraints,
+      limit: usize,
+    );
+    fn v8__ResourceConstraints__max_young_generation_size_in_bytes(
+      constraints: *const ResourceConstraints,
+    ) -> usize;
+    fn v8__ResourceConstraints__set_max_young_generation_size_in_bytes(
+      constraints: *mut ResourceConstraints,
+      limit: usize,
+    );
+    fn v8__ResourceConstraints__code_range_size_in_bytes(
+      constraints: *const ResourceConstraints,
+    ) -> usize;
+    fn v8__ResourceConstraints__set_code_range_size_in_bytes(
+      constraints: *mut ResourceConstraints,
+      limit: usize,
+    );
+    fn v8__ResourceConstraints__stack_limit(
+      constraints: *const ResourceConstraints,
+    ) -> *mut u32;
+    fn v8__ResourceConstraints__set_stack_limit(
+      constraints: *mut ResourceConstraints,
+      value: *mut u32,
+    );
+    fn v8__ResourceConstraints__initial_old_generation_size_in_bytes(
+      constraints: *const ResourceConstraints,
+    ) -> usize;
+    fn v8__ResourceConstraints__set_initial_old_generation_size_in_bytes(
+      constraints: *mut ResourceConstraints,
+      initial_size: usize,
+    );
+    fn v8__ResourceConstraints__initial_young_generation_size_in_bytes(
+      constraints: *const ResourceConstraints,
+    ) -> usize;
+    fn v8__ResourceConstraints__set_initial_young_generation_size_in_bytes(
+      constraints: *mut ResourceConstraints,
+      initial_size: usize,
+    );
   }
 
   impl ResourceConstraints {
@@ -297,5 +446,91 @@ pub(crate) mod raw {
         );
       }
     }
+
+    pub fn max_old_generation_size_in_bytes(&self) -> usize {
+      unsafe {
+        v8__ResourceConstraints__max_old_generation_size_in_bytes(self)
+      }
+    }
+
+    pub fn set_max_old_generation_size_in_bytes(&mut self, limit: usize) {
+      unsafe {
+        v8__ResourceConstraints__set_max_old_generation_size_in_bytes(
+          self, limit,
+        );
+      }
+    }
+
+    pub fn max_young_generation_size_in_bytes(&self) -> usize {
+      unsafe {
+        v8__ResourceConstraints__max_young_generation_size_in_bytes(self)
+      }
+    }
+
+    pub fn set_max_young_generation_size_in_bytes(&mut self, limit: usize) {
+      unsafe {
+        v8__ResourceConstraints__set_max_young_generation_size_in_bytes(
+          self, limit,
+        );
+      }
+    }
+
+    pub fn code_range_size_in_bytes(&self) -> usize {
+      unsafe {
+        v8__ResourceConstraints__code_range_size_in_bytes(self)
+      }
+    }
+
+    pub fn set_code_range_size_in_bytes(&mut self, limit: usize) {
+      unsafe {
+        v8__ResourceConstraints__set_code_range_size_in_bytes(self, limit);
+      }
+    }
+
+    pub fn stack_limit(&self) -> *mut u32 {
+      unsafe { v8__ResourceConstraints__stack_limit(self) }
+    }
+
+    pub fn set_stack_limit(&mut self, value: *mut u32) {
+      unsafe {
+        v8__ResourceConstraints__set_stack_limit(self, value);
+      }
+    }
+
+    pub fn initial_old_generation_size_in_bytes(&self) -> usize {
+      unsafe {
+        v8__ResourceConstraints__initial_old_generation_size_in_bytes(self)
+      }
+    }
+
+    pub fn set_initial_old_generation_size_in_bytes(
+      &mut self,
+      initial_size: usize,
+    ) {
+      unsafe {
+        v8__ResourceConstraints__set_initial_old_generation_size_in_bytes(
+          self,
+          initial_size,
+        );
+      }
+    }
+
+    pub fn initial_young_generation_size_in_bytes(&self) -> usize {
+      unsafe {
+        v8__ResourceConstraints__initial_young_generation_size_in_bytes(self)
+      }
+    }
+
+    pub fn set_initial_young_generation_size_in_bytes(
+      &mut self,
+      initial_size: usize,
+    ) {
+      unsafe {
+        v8__ResourceConstraints__set_initial_young_generation_size_in_bytes(
+          self,
+          initial_size,
+        );
+      }
+    }
   }
 }