feat: add 100% JSI/Hermes API coverage (#6)

* fix: update hermes submodule to static_h branch

The default branch for hermes changed from main to static_h. This
updates the submodule and fixes breaking API changes: the libhermes
cmake target was renamed to hermesvm_a, ES6Promise/ES6Class config
options were removed (always-on), withEnableBlockScoping was renamed
to withES6BlockScoping, and static utility methods moved from
HermesRuntime to the IHermesRootAPI interface.

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

* feat: add 100% JSI/Hermes API coverage with new bindings

Adds ~30 new C binding functions across 4 phases:
- Core JSI: BigInt::getInt64, queueMicrotask, deleteProperty (3 overloads),
  computed property access (3 overloads), prototype operations (3 overloads)
- Hermes-specific: fatal handler, bytecode epilogue, code coverage profiler,
  per-runtime profiling, load segment, unique IDs (6 types), timezone cache
- RuntimeConfig: 7 new JIT/bytecode config fields
- Rust wrappers: Safe APIs for all new functions with lifetime safety
- Examples: New prototypes example, enhanced advanced.rs with new features
- Tests: 18 new tests covering all new APIs

Co-Authored-By: Claude Haiku 4.5 <noreply@anthropic.com>

---------

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

Author: mishushakov

.gitmodules

@@ -1,4 +1,4 @@
 [submodule "libhermesabi-sys/hermes"]
 	path = libhermesabi-sys/hermes
 	url = https://github.com/facebook/hermes.git
-	branch = main
+	branch = static_h

README.md

@@ -10,16 +10,19 @@ Rust wrapper for [Hermes](https://hermesengine.dev) JavaScript engine.
 ## Quick start
 
 ```rust
-use rusty_hermes::Runtime;
+use rusty_hermes::{Runtime, hermes_op};
+
+#[hermes_op]
+fn add(a: f64, b: f64) -> f64 { a + b }
 
 let rt = Runtime::new().unwrap();
 
 // Evaluate JavaScript
 let val = rt.eval("1 + 2").unwrap();
 assert_eq!(val.as_number(), Some(3.0));
 
-// Register a host function
-rt.set_func("add", |a: f64, b: f64| -> f64 { a + b }).unwrap();
+// Register a host function and call it from JS
+add::register(&rt).unwrap();
 let result = rt.eval("add(10, 20)").unwrap();
 assert_eq!(result.as_number(), Some(30.0));
 ```
@@ -79,15 +82,18 @@ rt.eval("add_points({x: 1, y: 2}, {x: 3, y: 4})").unwrap();
 - **Rich type conversions** — `IntoJs`/`FromJs` for all numeric types, `String`, `bool`, `Option<T>`, `Vec<T>`, `HashMap<String, T>`, `BTreeMap<String, T>`, `HashSet<T>`, `BTreeSet<T>`
 - **Host functions** — register Rust closures as JS functions with automatic type conversion (up to 8 args)
 - **Host objects** — create JS objects backed by Rust callbacks for custom get/set/property enumeration
-- **Object manipulation** — get/set/has properties (string and PropNameId keys), property enumeration, instanceof, NativeState
+- **Object manipulation** — get/set/has/delete properties (string, PropNameId, and Value keys), property enumeration, instanceof, NativeState, prototype get/set/create
 - **ArrayBuffer** — create, read, and write raw byte buffers
 - **PreparedJavaScript** — pre-compile scripts for repeated evaluation
 - **Scope** — RAII handle scopes for GC pressure management
 - **WeakObject** — weak references to JS objects
-- **RuntimeConfig** — builder pattern for configuring eval, Promise, Proxy, Intl, microtask queue, etc.
+- **Microtask queue** — queue microtasks and drain them
+- **RuntimeConfig** — builder pattern for configuring eval, Proxy, Intl, microtask queue, JIT, async generators, and more
 - **Execution limits** — watch/unwatch time limits for runaway scripts
-- **Bytecode utilities** — check, validate, and prefetch Hermes bytecode
-- **Sampling profiler** — enable/disable profiling and dump traces
+- **Bytecode utilities** — check, validate, prefetch Hermes bytecode, and read bytecode epilogue
+- **Sampling profiler** — enable/disable profiling, per-runtime registration, and dump traces
+- **Code coverage profiler** — enable/disable code coverage tracking
+- **Unique IDs** — Hermes-specific unique identifiers for objects, strings, symbols, bigints, and prop names
 - **Lifetime safety** — all JS values carry a `'rt` lifetime tied to their `Runtime`, preventing use-after-free at compile time
 - **Derive macros** — `#[derive(IntoJs, FromJs)]` for automatic Rust ↔ JS struct/enum conversion
 - **Ops system** — `#[hermes_op]` attribute macro for declaring host functions with auto type conversion and error propagation
@@ -131,4 +137,5 @@ cargo run --example host_functions
 cargo run --example objects_and_arrays
 cargo run --example advanced
 cargo run --example derive
+cargo run --example prototypes
 ```

examples/advanced.rs

@@ -1,11 +1,11 @@
 //! Advanced features demo — RuntimeConfig, JSON, PreparedJS, ArrayBuffer,
-//! BigInt, Scope, and time limits.
+//! BigInt, Scope, time limits, microtask queue, unique IDs, and code coverage.
 //!
 //! Run with:
 //!   cargo run --example advanced
 
 use rusty_hermes::{
-    ArrayBuffer, BigInt, PropNameId, Runtime, RuntimeConfig, Scope,
+    ArrayBuffer, BigInt, JsString, Object, PropNameId, Runtime, RuntimeConfig, Scope, Value,
 };
 
 fn main() {
@@ -32,6 +32,38 @@ fn main() {
     let version = obj.get_with_propname(&key).unwrap();
     println!("version (via PropNameId) = {}", version.as_number().unwrap());
 
+    // -- Delete property -----------------------------------------------------
+    obj.set("temp", Value::from_number(99.0)).unwrap();
+    assert!(obj.has("temp"));
+    obj.delete("temp").unwrap();
+    assert!(!obj.has("temp"));
+    println!("Delete property: OK");
+
+    // -- Computed property access (Value key) ---------------------------------
+    let arr_val = rt
+        .create_value_from_json("[10, 20, 30]")
+        .unwrap();
+    let arr_obj = arr_val.into_object().unwrap();
+    let idx = Value::from_number(1.0);
+    let elem = arr_obj.get_with_value(&idx).unwrap();
+    println!("arr[1] via Value key = {}", elem.as_number().unwrap());
+
+    // -- Unique IDs ----------------------------------------------------------
+    let obj1 = Object::new(&rt);
+    let obj2 = Object::new(&rt);
+    println!(
+        "Unique IDs: obj1={}, obj2={} (different={})",
+        obj1.unique_id(),
+        obj2.unique_id(),
+        obj1.unique_id() != obj2.unique_id()
+    );
+
+    let s1 = JsString::new(&rt, "hello");
+    println!("String unique ID: {}", s1.unique_id());
+
+    let pn = PropNameId::from_utf8(&rt, "test");
+    println!("PropNameId unique ID: {}", pn.unique_id());
+
     // -- PreparedJavaScript (compile once, run many) -------------------------
     let prepared = rt.prepare_javascript("1 + 2 + 3", "compiled.js").unwrap();
     let r1 = rt.evaluate_prepared_javascript(&prepared).unwrap();
@@ -77,6 +109,11 @@ fn main() {
     let hex = big.to_js_string(16);
     println!("BigInt (hex): 0x{}", hex.to_rust_string().unwrap());
 
+    // BigInt i64 round-trip
+    let neg = BigInt::from_i64(&rt, -42);
+    assert_eq!(neg.truncate_to_i64(), -42);
+    println!("BigInt i64 round-trip: -42 = {}", neg.truncate_to_i64());
+
     // -- Scope ---------------------------------------------------------------
     {
         let _scope = Scope::new(&rt);
@@ -103,9 +140,35 @@ fn main() {
     println!("With time limit: {}", val.as_number().unwrap());
     rt.unwatch_time_limit();
 
-    // -- Drain microtasks ----------------------------------------------------
+    // -- Queue microtask & drain ---------------------------------------------
+    rt.eval("var microtaskResult = 0").unwrap();
+    let func = rt
+        .eval("(function() { microtaskResult = 123; })")
+        .unwrap()
+        .into_function()
+        .unwrap();
+    rt.queue_microtask(&func).unwrap();
     let drained = rt.drain_microtasks().unwrap();
-    println!("Microtasks drained: {drained}");
+    let result = rt.eval("microtaskResult").unwrap();
+    println!(
+        "Microtask: drained={drained}, result={}",
+        result.as_number().unwrap()
+    );
+
+    // -- Code coverage profiler ----------------------------------------------
+    println!(
+        "Code coverage profiler enabled: {}",
+        Runtime::is_code_coverage_profiler_enabled()
+    );
+
+    // -- Profiling registration ----------------------------------------------
+    rt.register_for_profiling();
+    rt.unregister_for_profiling();
+    println!("Profiling register/unregister: OK");
+
+    // -- Reset timezone cache ------------------------------------------------
+    rt.reset_timezone_cache();
+    println!("Reset timezone cache: OK");
 
     println!("\nAll advanced features working!");
 }

examples/prototypes.rs

@@ -0,0 +1,77 @@
+//! Prototype operations demo — create objects with prototypes, get/set
+//! prototype chains, and demonstrate inheritance.
+//!
+//! Run with:
+//!   cargo run --example prototypes
+
+use rusty_hermes::{Object, Runtime, Value};
+
+fn main() {
+    let rt = Runtime::new().expect("failed to create Hermes runtime");
+
+    // Create a prototype object with a method
+    let animal = Object::new(&rt);
+    animal
+        .set("type", Value::from(rusty_hermes::JsString::new(&rt, "animal")))
+        .unwrap();
+    animal
+        .set("legs", Value::from_number(4.0))
+        .unwrap();
+
+    println!("Prototype: type={}", {
+        let t = animal.get("type").unwrap().into_string().unwrap();
+        t.to_rust_string().unwrap()
+    });
+
+    // Create a child object with the prototype
+    let proto_val: Value = animal.into();
+    let dog = Object::create_with_prototype(&rt, &proto_val).unwrap();
+    dog.set("name", Value::from(rusty_hermes::JsString::new(&rt, "Rex")))
+        .unwrap();
+
+    // Child inherits properties from prototype
+    let inherited_type = dog.get("type").unwrap().into_string().unwrap();
+    println!(
+        "Dog name={}, inherited type={}",
+        dog.get("name")
+            .unwrap()
+            .into_string()
+            .unwrap()
+            .to_rust_string()
+            .unwrap(),
+        inherited_type.to_rust_string().unwrap()
+    );
+
+    // Verify prototype chain
+    let retrieved = dog.get_prototype().unwrap();
+    assert!(retrieved.is_object());
+    println!("get_prototype() returned an object: OK");
+
+    // Change prototype dynamically
+    let new_proto = Object::new(&rt);
+    new_proto
+        .set("sound", Value::from(rusty_hermes::JsString::new(&rt, "meow")))
+        .unwrap();
+    let new_proto_val: Value = new_proto.into();
+    dog.set_prototype(&new_proto_val).unwrap();
+
+    let sound = dog.get("sound").unwrap().into_string().unwrap();
+    println!("After set_prototype, sound = {}", sound.to_rust_string().unwrap());
+
+    // Old inherited property is gone
+    let old_type = dog.get("type").unwrap();
+    assert!(old_type.is_undefined());
+    println!("Old inherited 'type' is now undefined: OK");
+
+    // Unique IDs
+    let obj_a = Object::new(&rt);
+    let obj_b = Object::new(&rt);
+    println!(
+        "Unique IDs: a={}, b={} (different={})",
+        obj_a.unique_id(),
+        obj_b.unique_id(),
+        obj_a.unique_id() != obj_b.unique_id()
+    );
+
+    println!("\nAll prototype operations working!");
+}

libhermesabi-sys/README.md

@@ -37,21 +37,21 @@ unsafe {
 
 ## API surface
 
-- **Runtime** — create (default/custom config), delete, evaluate JS, evaluate with source map, drain microtasks, get global object, parse JSON, description, inspectable
-- **RuntimeConfig** — eval, Promise, Proxy, Class, Intl, microtask queue, generators, block scoping, HermesInternal, max registers
+- **Runtime** — create (default/custom config), delete, evaluate JS, evaluate with source map, drain microtasks, queue microtask, get global object, parse JSON, description, inspectable, register/unregister for profiling, load segment, reset timezone cache
+- **RuntimeConfig** — eval, Proxy, Intl, microtask queue, generators, block scoping, HermesInternal, max registers, JIT (enable/force/threshold/memory limit), async generators, bytecode warmup percent, randomize memory layout
 - **PreparedJavaScript** — prepare, evaluate, delete
 - **Scope** — push/pop handle scopes
-- **String** — create from UTF-8/ASCII, convert to UTF-8, equality, release
-- **PropNameID** — create from string/UTF-8/ASCII/symbol, convert to UTF-8, equality, release
-- **Object** — create, get/set/has property (string and PropNameID keys), property names, type checks, instanceof, external memory pressure, NativeState (has/get/set), HostObject (create/get/is), release
+- **String** — create from UTF-8/ASCII, convert to UTF-8, equality, unique ID, release
+- **PropNameID** — create from string/UTF-8/ASCII/symbol, convert to UTF-8, equality, unique ID, release
+- **Object** — create, get/set/has/delete property (string, PropNameID, and Value keys), property names, type checks, instanceof, external memory pressure, NativeState (has/get/set), HostObject (create/get/is), prototype (create/get/set), unique ID, release
 - **Array** — create, size, get/set by index, release
 - **ArrayBuffer** — create, size, data pointer
 - **Function** — call (with/without this), call as constructor, create from host function, is host function, release
-- **Value** — release, strict equality, to string, clone
-- **Symbol** — to string, equality, release
-- **BigInt** — create from i64/u64, type checks, truncate, to string, equality, release
+- **Value** — release, strict equality, to string, clone, unique ID
+- **Symbol** — to string, equality, unique ID, release
+- **BigInt** — create from i64/u64, type checks, truncate to u64, get i64, to string, equality, unique ID, release
 - **WeakObject** — create, lock, release
-- **Hermes-specific** — bytecode check/version/sanity/prefetch, time limits (watch/unwatch/trigger), sampling profiler (enable/disable/dump)
+- **Hermes-specific** — bytecode check/version/sanity/prefetch/epilogue, time limits (watch/unwatch/trigger), sampling profiler (enable/disable/dump), code coverage profiler (enable/disable/query), fatal handler, unique IDs for all pointer types
 
 ## Installation
 

libhermesabi-sys/build.rs

@@ -13,10 +13,10 @@ fn main() {
     println!("cargo:rerun-if-changed=src/binding.hpp");
     println!("cargo:rerun-if-changed={}/", hermes_src_dir);
 
-    // Build Hermes via cmake, targeting libhermes (JSI implementation).
+    // Build Hermes via cmake, targeting hermesvm_a (static VM with compiler).
     // All libraries are built as static archives.
     let hermes_build = Config::new(hermes_src_dir)
-        .build_target("libhermes")
+        .build_target("hermesvm_a")
         .configure_arg("-G Ninja")
         .define("HERMES_ENABLE_EH_RTTI", "ON")
         .define("BUILD_SHARED_LIBS", "OFF")