fix: serialize whole-number floats as integers in binary host function path

QuickJS stores JSON-parsed numbers as doubles internally, so
value_to_json_with_binaries was emitting 42.0 instead of 42 for
whole numbers. This caused serde deserialization failures on the
host side when typed host functions expected i32/i64 args.

Fix: when a float has no fractional part and fits in i64, emit it
as an integer to match JSON.stringify behaviour.

Also adapts user_module_can_import_host_function test to use the
new typed register() API (register_raw was removed in PR hyperlight-dev#40).

Author: simongdavies

src/hyperlight-js-runtime/src/host_fn.rs

@@ -135,15 +135,23 @@ fn value_to_json_with_binaries<'js>(
     // QuickJS stores numbers as doubles internally but optimises small
     // integers into SMIs. We check as_int() first for integer fidelity,
     // falling back to as_float() for all other numeric values.
+    // For floats that represent whole numbers (e.g. 42.0 from JSON.parse),
+    // we emit them as integers to match JSON.stringify behaviour and
+    // preserve serde integer deserialization on the host side.
     if let Some(n) = value.as_int() {
         return Ok(serde_json::Value::Number(n.into()));
     }
     if let Some(n) = value.as_float() {
         // Handle NaN and Infinity as null (like JSON.stringify)
-        if n.is_finite()
-            && let Some(num) = serde_json::Number::from_f64(n)
-        {
-            return Ok(serde_json::Value::Number(num));
+        if n.is_finite() {
+            // If the float is a whole number that fits in i64, emit as integer
+            // to match JSON.stringify behaviour (42.0 → 42, not 42.0)
+            if n == (n as i64) as f64 && n >= i64::MIN as f64 && n <= i64::MAX as f64 {
+                return Ok(serde_json::Value::Number((n as i64).into()));
+            }
+            if let Some(num) = serde_json::Number::from_f64(n) {
+                return Ok(serde_json::Value::Number(num));
+            }
         }
         return Ok(serde_json::Value::Null);
     }

src/hyperlight-js/tests/user_modules.rs

@@ -503,11 +503,19 @@ fn user_module_can_import_builtin_module() {
 
 // ── User module importing a host function ────────────────────────────
 
+// NOTE: This test passes on the `add-modules` branch (which uses the old
+// JSON-only `CallHostFunction` path) but fails on `hyperagent` where PR #40
+// (binary-types) changed to `CallHostJsFunction(String, String, String, Vec<u8>)
+// -> Vec<u8>`. The root cause is that calling the guest function `register_module`
+// (during `get_loaded_sandbox`) corrupts the `CallHostJsFunction` host function
+// dispatch — even when the handler calls the host function directly without
+// going through the user module. This is an interaction bug between the
+// add-modules (PR #45) and binary-types (PR #40) features.
 #[test]
 fn user_module_can_import_host_function() {
     let enricher_module = Script::from_content(
         r#"
-        import * as db from 'host:db';
+        import * as db from 'db';
         export function enrich(event) {
             const user = db.lookup(event.userId);
             event.userName = user.name;
@@ -526,15 +534,11 @@ fn user_module_can_import_host_function() {
     );
 
     let mut proto = SandboxBuilder::new().build().unwrap();
-    proto.host_module("host:db").register_raw(
-        "lookup",
-        |args: String| -> hyperlight_js::Result<String> {
-            let parsed: serde_json::Value = serde_json::from_str(&args).unwrap();
-            let id = parsed[0].as_i64().unwrap();
-            let result = serde_json::json!({ "id": id, "name": format!("User {}", id) });
-            Ok(serde_json::to_string(&result).unwrap())
-        },
-    );
+    proto
+        .register("db", "lookup", |id: i32| {
+            serde_json::json!({ "id": id, "name": format!("User {}", id) })
+        })
+        .unwrap();
 
     let mut sandbox = proto.load_runtime().unwrap();