fix: serialize whole-number floats as integers in extract_binaries

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 adds 7 numeric type tests covering i32, i64, f64, bool, mixed
types, negative integers, and zero — all passing through the binary
host function path with event data (JSON-parsed → float → host).

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/host_functions.rs

@@ -513,3 +513,195 @@ fn register_js_binary_in_nested_object() {
 
     assert_eq!(res, r#"{"result":"test-3"}"#);
 }
+
+// ── Numeric type tests ───────────────────────────────────────────────
+// QuickJS stores JSON-parsed numbers as doubles internally. The binary
+// host function path (extract_binaries → value_to_json_with_binaries)
+// must serialize whole-number floats as integers to preserve serde
+// deserialization on the host side.
+
+#[test]
+fn host_fn_with_i32_arg_from_event_data() {
+    // event.x is parsed from JSON → stored as f64 in QuickJS → must
+    // arrive at the host as an integer, not 42.0
+    let handler = Script::from_content(
+        r#"
+        import * as math from "math";
+        function handler(event) {
+            return { result: math.double(event.x) };
+        }
+        "#,
+    );
+
+    let mut proto = SandboxBuilder::new().build().unwrap();
+    proto.register("math", "double", |x: i32| x * 2).unwrap();
+
+    let mut sandbox = proto.load_runtime().unwrap();
+    sandbox.add_handler("handler", handler).unwrap();
+    let mut loaded = sandbox.get_loaded_sandbox().unwrap();
+
+    let res = loaded
+        .handle_event("handler", r#"{"x": 42}"#.to_string(), None)
+        .unwrap();
+    assert_eq!(res, r#"{"result":84}"#);
+}
+
+#[test]
+fn host_fn_with_i64_arg_from_event_data() {
+    let handler = Script::from_content(
+        r#"
+        import * as math from "math";
+        function handler(event) {
+            return { result: math.negate(event.x) };
+        }
+        "#,
+    );
+
+    let mut proto = SandboxBuilder::new().build().unwrap();
+    proto.register("math", "negate", |x: i64| -x).unwrap();
+
+    let mut sandbox = proto.load_runtime().unwrap();
+    sandbox.add_handler("handler", handler).unwrap();
+    let mut loaded = sandbox.get_loaded_sandbox().unwrap();
+
+    let res = loaded
+        .handle_event("handler", r#"{"x": 100}"#.to_string(), None)
+        .unwrap();
+    assert_eq!(res, r#"{"result":-100}"#);
+}
+
+#[test]
+fn host_fn_with_f64_arg_preserves_fractional() {
+    // Actual floats (3.14) must remain as floats, not be truncated
+    let handler = Script::from_content(
+        r#"
+        import * as math from "math";
+        function handler(event) {
+            return { result: math.half(event.x) };
+        }
+        "#,
+    );
+
+    let mut proto = SandboxBuilder::new().build().unwrap();
+    proto.register("math", "half", |x: f64| x / 2.0).unwrap();
+
+    let mut sandbox = proto.load_runtime().unwrap();
+    sandbox.add_handler("handler", handler).unwrap();
+    let mut loaded = sandbox.get_loaded_sandbox().unwrap();
+
+    let res = loaded
+        .handle_event("handler", r#"{"x": 3.14}"#.to_string(), None)
+        .unwrap();
+
+    let json: serde_json::Value = serde_json::from_str(&res).unwrap();
+    let result = json["result"].as_f64().unwrap();
+    assert!(
+        (result - 1.57).abs() < 0.001,
+        "Expected ~1.57, got {result}"
+    );
+}
+
+#[test]
+fn host_fn_with_bool_arg() {
+    let handler = Script::from_content(
+        r#"
+        import * as logic from "logic";
+        function handler(event) {
+            return { result: logic.flip(event.flag) };
+        }
+        "#,
+    );
+
+    let mut proto = SandboxBuilder::new().build().unwrap();
+    proto.register("logic", "flip", |b: bool| !b).unwrap();
+
+    let mut sandbox = proto.load_runtime().unwrap();
+    sandbox.add_handler("handler", handler).unwrap();
+    let mut loaded = sandbox.get_loaded_sandbox().unwrap();
+
+    let res = loaded
+        .handle_event("handler", r#"{"flag": true}"#.to_string(), None)
+        .unwrap();
+    assert_eq!(res, r#"{"result":false}"#);
+}
+
+#[test]
+fn host_fn_with_mixed_numeric_types() {
+    // i32 + f64 mix in the same call
+    let handler = Script::from_content(
+        r#"
+        import * as math from "math";
+        function handler(event) {
+            return { result: math.weighted_add(event.a, event.b, event.weight) };
+        }
+        "#,
+    );
+
+    let mut proto = SandboxBuilder::new().build().unwrap();
+    proto
+        .register("math", "weighted_add", |a: i32, b: i32, w: f64| {
+            (a as f64 * w + b as f64 * (1.0 - w)) as i32
+        })
+        .unwrap();
+
+    let mut sandbox = proto.load_runtime().unwrap();
+    sandbox.add_handler("handler", handler).unwrap();
+    let mut loaded = sandbox.get_loaded_sandbox().unwrap();
+
+    let res = loaded
+        .handle_event(
+            "handler",
+            r#"{"a": 100, "b": 200, "weight": 0.75}"#.to_string(),
+            None,
+        )
+        .unwrap();
+    assert_eq!(res, r#"{"result":125}"#);
+}
+
+#[test]
+fn host_fn_with_negative_integer() {
+    let handler = Script::from_content(
+        r#"
+        import * as math from "math";
+        function handler(event) {
+            return { result: math.abs(event.x) };
+        }
+        "#,
+    );
+
+    let mut proto = SandboxBuilder::new().build().unwrap();
+    proto.register("math", "abs", |x: i32| x.abs()).unwrap();
+
+    let mut sandbox = proto.load_runtime().unwrap();
+    sandbox.add_handler("handler", handler).unwrap();
+    let mut loaded = sandbox.get_loaded_sandbox().unwrap();
+
+    let res = loaded
+        .handle_event("handler", r#"{"x": -42}"#.to_string(), None)
+        .unwrap();
+    assert_eq!(res, r#"{"result":42}"#);
+}
+
+#[test]
+fn host_fn_with_zero() {
+    let handler = Script::from_content(
+        r#"
+        import * as math from "math";
+        function handler(event) {
+            return { result: math.inc(event.x) };
+        }
+        "#,
+    );
+
+    let mut proto = SandboxBuilder::new().build().unwrap();
+    proto.register("math", "inc", |x: i32| x + 1).unwrap();
+
+    let mut sandbox = proto.load_runtime().unwrap();
+    sandbox.add_handler("handler", handler).unwrap();
+    let mut loaded = sandbox.get_loaded_sandbox().unwrap();
+
+    let res = loaded
+        .handle_event("handler", r#"{"x": 0}"#.to_string(), None)
+        .unwrap();
+    assert_eq!(res, r#"{"result":1}"#);
+}