quickjs 0.13.0 → 0.15.0

data/ext/quickjsrb/quickjsrb.c

@@ -1,5 +1,6 @@
 #include "quickjsrb.h"
 #include "quickjsrb_file.h"
+#include "quickjsrb_crypto.h"
 
 const char *featureStdId = "feature_std";
 const char *featureOsId = "feature_os";
@@ -7,6 +8,8 @@ const char *featureTimeoutId = "feature_timeout";
 const char *featurePolyfillIntlId = "feature_polyfill_intl";
 const char *featurePolyfillFileId = "feature_polyfill_file";
 const char *featurePolyfillEncodingId = "feature_polyfill_encoding";
+const char *featurePolyfillUrlId = "feature_polyfill_url";
+const char *featurePolyfillCryptoId = "feature_polyfill_crypto";
 
 const char *undefinedId = "undefined";
 const char *nanId = "NaN";
@@ -23,6 +26,9 @@ const int num_native_errors = sizeof(native_errors) / sizeof(native_errors[0]);
 
 static int dispatch_log(VMData *data, const char *severity, VALUE r_row);
 
+JSValue to_js_value(JSContext *ctx, VALUE r_value);
+VALUE to_rb_value(JSContext *ctx, JSValue j_val);
+
 JSValue j_error_from_ruby_error(JSContext *ctx, VALUE r_error)
 {
   JSValue j_error = JS_NewError(ctx); // may wanna have custom error class to determine in JS' end
@@ -42,6 +48,20 @@ JSValue j_error_from_ruby_error(JSContext *ctx, VALUE r_error)
   return j_error;
 }
 
+typedef struct
+{
+  JSContext *ctx;
+  JSValue j_obj;
+} RbHashToJsArg;
+
+static int rb_hash_entry_to_js(VALUE r_key, VALUE r_val, VALUE extra)
+{
+  RbHashToJsArg *arg = (RbHashToJsArg *)extra;
+  VALUE r_key_str = rb_funcall(r_key, rb_intern("to_s"), 0);
+  JS_SetPropertyStr(arg->ctx, arg->j_obj, StringValueCStr(r_key_str), to_js_value(arg->ctx, r_val));
+  return ST_CONTINUE;
+}
+
 JSValue to_js_value(JSContext *ctx, VALUE r_value)
 {
   switch (TYPE(r_value))
@@ -71,6 +91,15 @@ JSValue to_js_value(JSContext *ctx, VALUE r_value)
   }
   case T_SYMBOL:
   {
+    if (r_value == QUICKJSRB_SYM(undefinedId))
+      return JS_UNDEFINED;
+    if (r_value == QUICKJSRB_SYM(nanId))
+    {
+      JSValue j_global = JS_GetGlobalObject(ctx);
+      JSValue j_nan = JS_GetPropertyStr(ctx, j_global, "NaN");
+      JS_FreeValue(ctx, j_global);
+      return j_nan;
+    }
     VALUE r_str = rb_funcall(r_value, rb_intern("to_s"), 0);
     char *str = StringValueCStr(r_str);
 
@@ -80,14 +109,22 @@ JSValue to_js_value(JSContext *ctx, VALUE r_value)
     return JS_TRUE;
   case T_FALSE:
     return JS_FALSE;
-  case T_HASH:
   case T_ARRAY:
   {
-    VALUE r_json_str = rb_funcall(r_value, rb_intern("to_json"), 0);
-    char *str = StringValueCStr(r_json_str);
-    JSValue j_parsed = JS_ParseJSON(ctx, str, strlen(str), "<quickjsrb.c>");
-
-    return j_parsed;
+    int len = RARRAY_LEN(r_value);
+    JSValue j_arr = JS_NewArray(ctx);
+    for (int i = 0; i < len; i++)
+    {
+      JS_SetPropertyUint32(ctx, j_arr, (uint32_t)i, to_js_value(ctx, RARRAY_AREF(r_value, i)));
+    }
+    return j_arr;
+  }
+  case T_HASH:
+  {
+    JSValue j_obj = JS_NewObject(ctx);
+    RbHashToJsArg arg = {ctx, j_obj};
+    rb_hash_foreach(r_value, rb_hash_entry_to_js, (VALUE)&arg);
+    return j_obj;
   }
   default:
   {
@@ -154,6 +191,59 @@ VALUE to_r_json(JSContext *ctx, JSValue j_val)
   return r_str;
 }
 
+static int js_is_plain_object(JSContext *ctx, JSValue j_val)
+{
+  JSValue j_proto = JS_GetPrototype(ctx, j_val);
+  if (JS_IsNull(j_proto))
+    return 1; // Object.create(null)
+  JSValue j_global = JS_GetGlobalObject(ctx);
+  JSValue j_Object = JS_GetPropertyStr(ctx, j_global, "Object");
+  JSValue j_Object_proto = JS_GetPropertyStr(ctx, j_Object, "prototype");
+  int result = JS_StrictEq(ctx, j_proto, j_Object_proto);
+  JS_FreeValue(ctx, j_proto);
+  JS_FreeValue(ctx, j_global);
+  JS_FreeValue(ctx, j_Object);
+  JS_FreeValue(ctx, j_Object_proto);
+  return result;
+}
+
+static VALUE js_array_to_rb(JSContext *ctx, JSValue j_val)
+{
+  JSValue j_length = JS_GetPropertyStr(ctx, j_val, "length");
+  uint32_t length = 0;
+  JS_ToUint32(ctx, &length, j_length);
+  JS_FreeValue(ctx, j_length);
+
+  VALUE r_array = rb_ary_new_capa(length);
+  for (uint32_t i = 0; i < length; i++)
+  {
+    JSValue j_elem = JS_GetPropertyUint32(ctx, j_val, i);
+    rb_ary_push(r_array, to_rb_value(ctx, j_elem));
+    JS_FreeValue(ctx, j_elem);
+  }
+  return r_array;
+}
+
+static VALUE js_plain_object_to_rb(JSContext *ctx, JSValue j_val)
+{
+  JSPropertyEnum *ptab;
+  uint32_t plen;
+  if (JS_GetOwnPropertyNames(ctx, &ptab, &plen, j_val, JS_GPN_STRING_MASK | JS_GPN_ENUM_ONLY) < 0)
+    return rb_hash_new();
+
+  VALUE r_hash = rb_hash_new();
+  for (uint32_t i = 0; i < plen; i++)
+  {
+    const char *key = JS_AtomToCString(ctx, ptab[i].atom);
+    JSValue j_prop = JS_GetProperty(ctx, j_val, ptab[i].atom);
+    rb_hash_aset(r_hash, rb_str_new2(key), to_rb_value(ctx, j_prop));
+    JS_FreeCString(ctx, key);
+    JS_FreeValue(ctx, j_prop);
+  }
+  JS_FreePropertyEnum(ctx, ptab, plen);
+  return r_hash;
+}
+
 VALUE to_rb_value(JSContext *ctx, JSValue j_val)
 {
   switch (JS_VALUE_GET_NORM_TAG(j_val))
@@ -197,6 +287,18 @@ VALUE to_rb_value(JSContext *ctx, JSValue j_val)
       return Qnil;
     }
 
+    if (JS_IsFunction(ctx, j_val))
+    {
+      JSValue j_toStringFunc = JS_GetPropertyStr(ctx, j_val, "toString");
+      JSValue j_source = JS_Call(ctx, j_toStringFunc, j_val, 0, NULL);
+      JS_FreeValue(ctx, j_toStringFunc);
+      const char *source = JS_ToCString(ctx, j_source);
+      JS_FreeValue(ctx, j_source);
+      VALUE r_source = rb_str_new2(source);
+      JS_FreeCString(ctx, source);
+      return rb_funcall(rb_path2class("Quickjs::Function"), rb_intern("new"), 1, r_source);
+    }
+
     if (JS_IsError(ctx, j_val))
     {
       VALUE r_maybe_ruby_error = find_ruby_error(ctx, j_val);
@@ -236,6 +338,13 @@ VALUE to_rb_value(JSContext *ctx, JSValue j_val)
         return r_maybe_file;
     }
 
+    if (JS_IsArray(ctx, j_val))
+      return js_array_to_rb(ctx, j_val);
+
+    if (js_is_plain_object(ctx, j_val))
+      return js_plain_object_to_rb(ctx, j_val);
+
+    // Fallback: non-plain objects (Date, RegExp, Map, class instances, functions, etc.)
     VALUE r_str = to_r_json(ctx, j_val);
 
     if (rb_funcall(r_str, rb_intern("=="), 1, rb_str_new2("undefined")))
@@ -486,20 +595,14 @@ static VALUE r_try_call_listener(VALUE r_args)
 
 static int dispatch_log(VMData *data, const char *severity, VALUE r_row)
 {
+  if (NIL_P(data->log_listener))
+    return 0;
+
   VALUE r_log = r_log_new(severity, r_row);
-  if (!NIL_P(data->log_listener))
-  {
-    VALUE r_args = rb_ary_new3(2, data->log_listener, r_log);
-    int error;
-    rb_protect(r_try_call_listener, r_args, &error);
-    if (error)
-      return error;
-  }
-  else
-  {
-    rb_ary_push(data->logs, r_log);
-  }
-  return 0;
+  VALUE r_args = rb_ary_new3(2, data->log_listener, r_log);
+  int error;
+  rb_protect(r_try_call_listener, r_args, &error);
+  return error;
 }
 
 static VALUE vm_m_on_log(VALUE r_self)
@@ -680,6 +783,18 @@ static VALUE vm_m_initialize(int argc, VALUE *argv, VALUE r_self)
     JS_FreeValue(data->context, j_polyfillEncodingResult);
   }
 
+  if (RTEST(rb_funcall(r_features, rb_intern("include?"), 1, QUICKJSRB_SYM(featurePolyfillUrlId))))
+  {
+    JSValue j_polyfillUrlObject = JS_ReadObject(data->context, &qjsc_polyfill_url_min, qjsc_polyfill_url_min_size, JS_READ_OBJ_BYTECODE);
+    JSValue j_polyfillUrlResult = JS_EvalFunction(data->context, j_polyfillUrlObject);
+    JS_FreeValue(data->context, j_polyfillUrlResult);
+  }
+
+  if (RTEST(rb_funcall(r_features, rb_intern("include?"), 1, QUICKJSRB_SYM(featurePolyfillCryptoId))))
+  {
+    quickjsrb_init_crypto(data->context, j_global);
+  }
+
   JSValue j_console = JS_NewObject(data->context);
   JS_SetPropertyStr(
       data->context, j_console, "log",
@@ -713,6 +828,20 @@ static int interrupt_handler(JSRuntime *runtime, void *opaque)
   return elapsed_ms >= eval_time->limit_ms ? 1 : 0;
 }
 
+static VALUE to_rb_return_value(JSContext *ctx, JSValue j_val)
+{
+  if (JS_VALUE_GET_NORM_TAG(j_val) == JS_TAG_OBJECT && JS_PromiseState(ctx, j_val) != -1)
+  {
+    JS_FreeValue(ctx, j_val);
+    VALUE r_error_message = rb_str_new2("An unawaited Promise was returned to the top-level");
+    rb_exc_raise(rb_funcall(QUICKJSRB_ERROR_FOR(QUICKJSRB_NO_AWAIT_ERROR), rb_intern("new"), 2, r_error_message, Qnil));
+    return Qnil;
+  }
+  VALUE result = to_rb_value(ctx, j_val);
+  JS_FreeValue(ctx, j_val);
+  return result;
+}
+
 static VALUE vm_m_evalCode(VALUE r_self, VALUE r_code)
 {
   VMData *data;
@@ -730,26 +859,11 @@ static VALUE vm_m_evalCode(VALUE r_self, VALUE r_code)
   char *code = StringValueCStr(r_code);
   JSValue j_codeResult = JS_Eval(data->context, code, strlen(code), "<code>", JS_EVAL_TYPE_GLOBAL | JS_EVAL_FLAG_ASYNC);
   JSValue j_awaitedResult = js_std_await(data->context, j_codeResult); // This frees j_codeResult
+  // JS_EVAL_FLAG_ASYNC wraps the result in {value, done} — extract the actual value
+  // Free j_awaitedResult before to_rb_return_value because it may raise (longjmp), which would skip cleanup
   JSValue j_returnedValue = JS_GetPropertyStr(data->context, j_awaitedResult, "value");
-  // Do this by rescuing to_rb_value
-  if (JS_VALUE_GET_NORM_TAG(j_returnedValue) == JS_TAG_OBJECT && JS_PromiseState(data->context, j_returnedValue) != -1)
-  {
-    JS_FreeValue(data->context, j_returnedValue);
-    JS_FreeValue(data->context, j_awaitedResult);
-    VALUE r_error_message = rb_str_new2("An unawaited Promise was returned to the top-level");
-    rb_exc_raise(rb_funcall(QUICKJSRB_ERROR_FOR(QUICKJSRB_NO_AWAIT_ERROR), rb_intern("new"), 2, r_error_message, Qnil));
-    return Qnil;
-  }
-  else
-  {
-    // Free j_awaitedResult before to_rb_value because to_rb_value may
-    // raise (longjmp) for JS exceptions, which would skip any cleanup
-    // after it and leak JS GC objects.
-    JS_FreeValue(data->context, j_awaitedResult);
-    VALUE result = to_rb_value(data->context, j_returnedValue);
-    JS_FreeValue(data->context, j_returnedValue);
-    return result;
-  }
+  JS_FreeValue(data->context, j_awaitedResult);
+  return to_rb_return_value(data->context, j_returnedValue);
 }
 
 static VALUE vm_m_defineGlobalFunction(int argc, VALUE *argv, VALUE r_self)
@@ -761,33 +875,253 @@ static VALUE vm_m_defineGlobalFunction(int argc, VALUE *argv, VALUE r_self)
   VALUE r_block;
   rb_scan_args(argc, argv, "10*&", &r_name, &r_flags, &r_block);
 
-  if (!(SYMBOL_P(r_name) || RB_TYPE_P(r_name, T_STRING)))
+  VMData *data;
+  TypedData_Get_Struct(r_self, VMData, &vm_type, data);
+
+  if (RB_TYPE_P(r_name, T_ARRAY))
+  {
+    long path_len = RARRAY_LEN(r_name);
+    if (path_len < 1)
+      rb_raise(rb_eArgError, "function's path array must not be empty");
+
+    for (long i = 0; i < path_len; i++)
+    {
+      VALUE r_seg = RARRAY_AREF(r_name, i);
+      if (!(SYMBOL_P(r_seg) || RB_TYPE_P(r_seg, T_STRING)))
+        rb_raise(rb_eTypeError, "function's name should be a Symbol or a String");
+    }
+
+    // Build internal lookup key by joining path segments with "."
+    // e.g. ["myLib", "hello"] -> :"myLib.hello"
+    VALUE r_segs = rb_ary_new();
+    for (long i = 0; i < path_len; i++)
+      rb_ary_push(r_segs, rb_funcall(RARRAY_AREF(r_name, i), rb_intern("to_s"), 0));
+    VALUE r_key_str = rb_funcall(r_segs, rb_intern("join"), 1, rb_str_new2("."));
+    VALUE r_key_sym = rb_funcall(r_key_str, rb_intern("to_sym"), 0);
+    rb_hash_aset(data->defined_functions, r_key_sym, r_block);
+
+    VALUE r_func_seg_str = rb_funcall(RARRAY_AREF(r_name, path_len - 1), rb_intern("to_s"), 0);
+    char *funcName = StringValueCStr(r_func_seg_str);
+
+    JSValueConst ruby_data[2];
+    ruby_data[0] = JS_NewString(data->context, StringValueCStr(r_key_str));
+    ruby_data[1] = JS_NewBool(data->context, RTEST(rb_funcall(r_flags, rb_intern("include?"), 1, ID2SYM(rb_intern("async")))));
+
+    // Resolve the parent object to attach the function to.
+    // For a single-element array, parent is the global object.
+    // For multi-element arrays, traverse path[0..n-2] using JS_Eval for the first
+    // segment (so lexical const/let bindings are resolved, not just global properties)
+    // and JS_GetPropertyStr for subsequent segments.
+    JSValue j_parent;
+    if (path_len == 1)
+    {
+      j_parent = JS_GetGlobalObject(data->context);
+    }
+    else
+    {
+      VALUE r_first_str = rb_funcall(RARRAY_AREF(r_name, 0), rb_intern("to_s"), 0);
+      const char *first_seg = StringValueCStr(r_first_str);
+      j_parent = JS_Eval(data->context, first_seg, strlen(first_seg), "<vm>", JS_EVAL_TYPE_GLOBAL);
+
+      if (JS_IsException(j_parent) || !JS_IsObject(j_parent))
+      {
+        JS_FreeValue(data->context, j_parent);
+        JS_FreeValue(data->context, ruby_data[0]);
+        JS_FreeValue(data->context, ruby_data[1]);
+        rb_raise(rb_eArgError, "cannot define function: '%s' is not an object", first_seg);
+      }
+
+      for (long i = 1; i < path_len - 1; i++)
+      {
+        VALUE r_seg_str = rb_funcall(RARRAY_AREF(r_name, i), rb_intern("to_s"), 0);
+        JSValue j_next = JS_GetPropertyStr(data->context, j_parent, StringValueCStr(r_seg_str));
+        JS_FreeValue(data->context, j_parent);
+
+        if (JS_IsException(j_next) || !JS_IsObject(j_next))
+        {
+          JS_FreeValue(data->context, j_next);
+          JS_FreeValue(data->context, ruby_data[0]);
+          JS_FreeValue(data->context, ruby_data[1]);
+          rb_raise(rb_eArgError, "cannot define function: '%s' is not an object", StringValueCStr(r_seg_str));
+        }
+        j_parent = j_next;
+      }
+    }
+
+    JS_SetPropertyStr(
+        data->context, j_parent, funcName,
+        JS_NewCFunctionData(data->context, js_quickjsrb_call_global, 1, 0, 2, ruby_data));
+    JS_FreeValue(data->context, j_parent);
+    JS_FreeValue(data->context, ruby_data[0]);
+    JS_FreeValue(data->context, ruby_data[1]);
+
+    VALUE r_result = rb_ary_new();
+    for (long i = 0; i < path_len; i++)
+      rb_ary_push(r_result, rb_funcall(RARRAY_AREF(r_name, i), rb_intern("to_sym"), 0));
+    return r_result;
+  }
+  else if (SYMBOL_P(r_name) || RB_TYPE_P(r_name, T_STRING))
+  {
+    VALUE r_name_sym = rb_funcall(r_name, rb_intern("to_sym"), 0);
+
+    rb_hash_aset(data->defined_functions, r_name_sym, r_block);
+    VALUE r_name_str = rb_funcall(r_name, rb_intern("to_s"), 0);
+    char *funcName = StringValueCStr(r_name_str);
+
+    JSValueConst ruby_data[2];
+    ruby_data[0] = JS_NewString(data->context, funcName);
+    ruby_data[1] = JS_NewBool(data->context, RTEST(rb_funcall(r_flags, rb_intern("include?"), 1, ID2SYM(rb_intern("async")))));
+
+    JSValue j_global = JS_GetGlobalObject(data->context);
+    JS_SetPropertyStr(
+        data->context, j_global, funcName,
+        JS_NewCFunctionData(data->context, js_quickjsrb_call_global, 1, 0, 2, ruby_data));
+    JS_FreeValue(data->context, j_global);
+    JS_FreeValue(data->context, ruby_data[0]);
+    JS_FreeValue(data->context, ruby_data[1]);
+
+    return r_name_sym;
+  }
+  else
   {
     rb_raise(rb_eTypeError, "function's name should be a Symbol or a String");
   }
+}
+
+static VALUE vm_m_callGlobalFunction(int argc, VALUE *argv, VALUE r_self)
+{
+  if (argc < 1)
+    rb_raise(rb_eArgError, "wrong number of arguments (given 0, expected 1+)");
+
+  VALUE r_name = argv[0];
 
   VMData *data;
   TypedData_Get_Struct(r_self, VMData, &vm_type, data);
 
-  VALUE r_name_sym = rb_funcall(r_name, rb_intern("to_sym"), 0);
+  JSValue j_this = JS_UNDEFINED;
+  JSValue j_func;
 
-  rb_hash_aset(data->defined_functions, r_name_sym, r_block);
-  VALUE r_name_str = rb_funcall(r_name, rb_intern("to_s"), 0);
-  char *funcName = StringValueCStr(r_name_str);
+  VALUE r_path;
+  if (SYMBOL_P(r_name) || RB_TYPE_P(r_name, T_STRING))
+  {
+    VALUE r_name_str = rb_funcall(r_name, rb_intern("to_s"), 0);
+    const char *name_str = StringValueCStr(r_name_str);
+    size_t name_len = strlen(name_str);
+    const char *last_bracket = strrchr(name_str, '[');
+    const char *last_dot = strrchr(name_str, '.');
 
-  JSValueConst ruby_data[2];
-  ruby_data[0] = JS_NewString(data->context, funcName);
-  ruby_data[1] = JS_NewBool(data->context, RTEST(rb_funcall(r_flags, rb_intern("include?"), 1, ID2SYM(rb_intern("async")))));
+    if (last_bracket != NULL && last_bracket != name_str && name_str[name_len - 1] == ']')
+    {
+      // Bracket notation: 'a["key"]' or 'a.b["key"]' or 'a[0]'
+      // Split into parent expression and the bracketed key
+      VALUE r_parent = rb_str_new(name_str, last_bracket - name_str);
+      const char *key_start = last_bracket + 1;
+      size_t key_len = name_len - (key_start - name_str) - 1; // exclude ']'
+      // Strip surrounding quotes for string keys: 'a["b"]' → key = b
+      if (key_len >= 2 &&
+          ((key_start[0] == '\'' && key_start[key_len - 1] == '\'') ||
+           (key_start[0] == '"' && key_start[key_len - 1] == '"')))
+      {
+        key_start++;
+        key_len -= 2;
+      }
+      VALUE r_key = rb_str_new(key_start, key_len);
+      r_path = rb_ary_new3(2, r_parent, r_key);
+    }
+    else if (last_dot != NULL && last_dot != name_str)
+    {
+      // Dot notation: 'a.b.c' → ['a.b', 'c'] so the parent becomes `this`
+      VALUE r_parent = rb_str_new(name_str, last_dot - name_str);
+      VALUE r_key = rb_str_new2(last_dot + 1);
+      r_path = rb_ary_new3(2, r_parent, r_key);
+    }
+    else
+    {
+      r_path = rb_ary_new3(1, r_name_str);
+    }
+  }
+  else
+  {
+    rb_raise(rb_eTypeError, "function's name should be a Symbol or a String");
+  }
 
-  JSValue j_global = JS_GetGlobalObject(data->context);
-  JS_SetPropertyStr(
-      data->context, j_global, funcName,
-      JS_NewCFunctionData(data->context, js_quickjsrb_call_global, 1, 0, 2, ruby_data));
-  JS_FreeValue(data->context, j_global);
-  JS_FreeValue(data->context, ruby_data[0]);
-  JS_FreeValue(data->context, ruby_data[1]);
+  {
+    long path_len = RARRAY_LEN(r_path);
+
+    VALUE r_first = RARRAY_AREF(r_path, 0);
+    if (!(SYMBOL_P(r_first) || RB_TYPE_P(r_first, T_STRING)))
+      rb_raise(rb_eTypeError, "function path elements should be Symbols or Strings");
+
+    VALUE r_first_str = rb_funcall(r_first, rb_intern("to_s"), 0);
+    const char *first_seg = StringValueCStr(r_first_str);
+
+    // JS_Eval accesses both global object properties and lexical (const/let) bindings
+    JSValue j_cur = JS_Eval(data->context, first_seg, strlen(first_seg), "<vm>", JS_EVAL_TYPE_GLOBAL);
+    if (JS_IsException(j_cur))
+      return to_rb_value(data->context, j_cur); // raises
+
+    for (long i = 1; i < path_len; i++)
+    {
+      VALUE r_seg = RARRAY_AREF(r_path, i);
+      if (!(SYMBOL_P(r_seg) || RB_TYPE_P(r_seg, T_STRING)))
+      {
+        JS_FreeValue(data->context, j_cur);
+        JS_FreeValue(data->context, j_this);
+        rb_raise(rb_eTypeError, "function path elements should be Symbols or Strings");
+      }
+      VALUE r_seg_str = rb_funcall(r_seg, rb_intern("to_s"), 0);
+      const char *seg = StringValueCStr(r_seg_str);
+
+      JSValue j_next = JS_GetPropertyStr(data->context, j_cur, seg);
+      if (JS_IsException(j_next))
+      {
+        JS_FreeValue(data->context, j_cur);
+        JS_FreeValue(data->context, j_this);
+        return to_rb_value(data->context, j_next); // raises
+      }
+
+      JS_FreeValue(data->context, j_this);
+      j_this = j_cur;
+      j_cur = j_next;
+    }
+
+    j_func = j_cur;
+  }
+
+  if (!JS_IsFunction(data->context, j_func))
+  {
+    JS_FreeValue(data->context, j_func);
+    JS_FreeValue(data->context, j_this);
+    VALUE r_error_message = rb_str_new2("given path is not a function");
+    rb_exc_raise(rb_funcall(QUICKJSRB_ERROR_FOR(QUICKJSRB_ROOT_RUNTIME_ERROR), rb_intern("new"), 2, r_error_message, Qnil));
+    return Qnil;
+  }
+
+  int nargs = argc - 1;
+  JSValue *j_args = NULL;
+  if (nargs > 0)
+  {
+    j_args = (JSValue *)malloc(sizeof(JSValue) * nargs);
+    for (int i = 0; i < nargs; i++)
+      j_args[i] = to_js_value(data->context, argv[i + 1]);
+  }
 
-  return r_name_sym;
+  clock_gettime(CLOCK_MONOTONIC, &data->eval_time->started_at);
+  JS_SetInterruptHandler(JS_GetRuntime(data->context), interrupt_handler, data->eval_time);
+
+  JSValue j_result = JS_Call(data->context, j_func, j_this, nargs, (JSValueConst *)j_args);
+
+  JS_FreeValue(data->context, j_func);
+  JS_FreeValue(data->context, j_this);
+  if (j_args)
+  {
+    for (int i = 0; i < nargs; i++)
+      JS_FreeValue(data->context, j_args[i]);
+    free(j_args);
+  }
+
+  // js_std_await handles both async (promise) and sync results; frees j_result
+  return to_rb_return_value(data->context, js_std_await(data->context, j_result));
 }
 
 static VALUE vm_m_import(int argc, VALUE *argv, VALUE r_self)
@@ -850,16 +1184,6 @@ static VALUE vm_m_import(int argc, VALUE *argv, VALUE r_self)
   return Qtrue;
 }
 
-static VALUE vm_m_logs(VALUE r_self)
-{
-  rb_category_warn(RB_WARN_CATEGORY_DEPRECATED, "Quickjs::VM#logs is deprecated; use Quickjs::VM#on_log instead");
-
-  VMData *data;
-  TypedData_Get_Struct(r_self, VMData, &vm_type, data);
-
-  return data->logs;
-}
-
 RUBY_FUNC_EXPORTED void Init_quickjsrb(void)
 {
   rb_require("json");
@@ -873,9 +1197,9 @@ RUBY_FUNC_EXPORTED void Init_quickjsrb(void)
   rb_define_alloc_func(r_class_vm, vm_alloc);
   rb_define_method(r_class_vm, "initialize", vm_m_initialize, -1);
   rb_define_method(r_class_vm, "eval_code", vm_m_evalCode, 1);
+  rb_define_method(r_class_vm, "call", vm_m_callGlobalFunction, -1);
   rb_define_method(r_class_vm, "define_function", vm_m_defineGlobalFunction, -1);
   rb_define_method(r_class_vm, "import", vm_m_import, -1);
-  rb_define_method(r_class_vm, "logs", vm_m_logs, 0);
   rb_define_method(r_class_vm, "on_log", vm_m_on_log, 0);
   r_define_log_class(r_class_vm);
 }

data/ext/quickjsrb/quickjsrb.h

@@ -18,6 +18,8 @@ extern const uint32_t qjsc_polyfill_file_min_size;
 extern const uint8_t qjsc_polyfill_file_min;
 extern const uint32_t qjsc_polyfill_encoding_min_size;
 extern const uint8_t qjsc_polyfill_encoding_min;
+extern const uint32_t qjsc_polyfill_url_min_size;
+extern const uint8_t qjsc_polyfill_url_min;
 
 extern const char *featureStdId;
 extern const char *featureOsId;
@@ -25,6 +27,8 @@ extern const char *featureTimeoutId;
 extern const char *featurePolyfillIntlId;
 extern const char *featurePolyfillFileId;
 extern const char *featurePolyfillEncodingId;
+extern const char *featurePolyfillUrlId;
+extern const char *featurePolyfillCryptoId;
 
 extern const char *undefinedId;
 extern const char *nanId;
@@ -48,7 +52,6 @@ typedef struct VMData
   struct JSContext *context;
   VALUE defined_functions;
   struct EvalTime *eval_time;
-  VALUE logs;
   VALUE log_listener;
   VALUE alive_objects;
   JSValue j_file_proxy_creator;
@@ -80,7 +83,6 @@ static void vm_mark(void *ptr)
 {
   VMData *data = (VMData *)ptr;
   rb_gc_mark_movable(data->defined_functions);
-  rb_gc_mark_movable(data->logs);
   rb_gc_mark_movable(data->log_listener);
   rb_gc_mark_movable(data->alive_objects);
 }
@@ -89,7 +91,6 @@ static void vm_compact(void *ptr)
 {
   VMData *data = (VMData *)ptr;
   data->defined_functions = rb_gc_location(data->defined_functions);
-  data->logs = rb_gc_location(data->logs);
   data->log_listener = rb_gc_location(data->log_listener);
   data->alive_objects = rb_gc_location(data->alive_objects);
 }
@@ -110,7 +111,6 @@ static VALUE vm_alloc(VALUE r_self)
   VMData *data;
   VALUE obj = TypedData_Make_Struct(r_self, VMData, &vm_type, data);
   data->defined_functions = rb_hash_new();
-  data->logs = rb_ary_new();
   data->log_listener = Qnil;
   data->alive_objects = rb_hash_new();
   data->j_file_proxy_creator = JS_UNDEFINED;
@@ -156,6 +156,8 @@ static void r_define_constants(VALUE r_parent_class)
   rb_define_const(r_parent_class, "POLYFILL_INTL", QUICKJSRB_SYM(featurePolyfillIntlId));
   rb_define_const(r_parent_class, "POLYFILL_FILE", QUICKJSRB_SYM(featurePolyfillFileId));
   rb_define_const(r_parent_class, "POLYFILL_ENCODING", QUICKJSRB_SYM(featurePolyfillEncodingId));
+  rb_define_const(r_parent_class, "POLYFILL_URL", QUICKJSRB_SYM(featurePolyfillUrlId));
+  rb_define_const(r_parent_class, "POLYFILL_CRYPTO", QUICKJSRB_SYM(featurePolyfillCryptoId));
 
   VALUE rb_cQuickjsValue = rb_define_class_under(r_parent_class, "Value", rb_cObject);
   rb_define_const(rb_cQuickjsValue, "UNDEFINED", QUICKJSRB_SYM(undefinedId));