quickjs 0.13.0.pre → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f27d3afc594731cc4df53661889a9787626121923ece35c544b581ef3f52722c
-  data.tar.gz: d3869683f9134339d1d2e44617845f8ece614e1503926841fb9d4ad6de3dc7ba
+  metadata.gz: 69b86d7c5040dba161c1d6f67cb3eab3fd8a3dc51b30eb6d355c2580dbc29602
+  data.tar.gz: 5e174baed18d79e0ac18a496f97cd580fd20830a98fb240351eeea46abe57683
 SHA512:
-  metadata.gz: b5cfcad98315e8821644aa233ea86213f855900506767ccce01cb0c1a653326456e3d00c453d0821117e31eee543ec440ed1e4583dd6b420a62e49ffcb53e080
-  data.tar.gz: 7df6cc20b91fce4c14e2a2b96b31bb447ee50eba03498a99e336c8b35d62164a05874ed7753509a4d0c1958761f96c5c85f4de66c6301b79eecbe208dbcf8212
+  metadata.gz: 9f7abcc1733fcfe9c51aacf81c9e34b05e7e44142a9db79a8bd4525ba67570f897cd7c1fb200428507876dad35a67b9a3f383711a3b0cfc9ff1b46728cd1c125
+  data.tar.gz: a15abae6b482f0df7efc89e9b0a3b9d3ca3bab8bb8d04ce7844f60b195a0314d8e12d2b3bbdf8cf01dae763e75945d4e84cf3c1efbe2a99d4cfa525e2279625e

data/README.md

@@ -23,17 +23,9 @@ gem 'quickjs'
 require 'quickjs'
 
 Quickjs.eval_code('const fn = (n, pow) => n ** pow; fn(2,8);') # => 256
-Quickjs.eval_code('const fn = (name) => `Hi, ${name}!`; fn("Itadori");') # => "Hi, Itadori!
-Quickjs.eval_code("const isOne = (n) => 1 === n; func(1);") #=> true (TrueClass)
-Quickjs.eval_code("const isOne = (n) => 1 === n; func(3);") #=> false (FalseClass)
-
-# When code returns 'object' for `typeof`, the result is converted via JSON.stringify (JS) -> JSON.parse (Ruby)
-Quickjs.eval_code("[1,2,3]") #=> [1, 2, 3] (Array)
-Quickjs.eval_code("({ a: '1', b: 1 })") #=> { 'a' => '1', 'b' => 1 } (Hash)
-
-Quickjs.eval_code("null") #=> nil
-Quickjs.eval_code('const obj = {}; obj.missingKey;') # => :undefined (Quickjs::Value::Undefined)
-Quickjs.eval_code("Number('whatever')") #=> :NaN (Quickjs::Value::NAN)
+Quickjs.eval_code('const fn = (name) => `Hi, ${name}!`; fn("Itadori");') # => "Hi, Itadori!"
+Quickjs.eval_code("[1,2,3]") #=> [1, 2, 3]
+Quickjs.eval_code("({ a: '1', b: 1 })") #=> { 'a' => '1', 'b' => 1 }
 ```
 
 <details>
@@ -42,36 +34,42 @@ Quickjs.eval_code("Number('whatever')") #=> :NaN (Quickjs::Value::NAN)
 #### Resources
 
 ```rb
-# 1GB memory limit
-Quickjs.eval_code(code, { memory_limit: 1024 ** 3 })
-
-# 1MB max stack size
-Quickjs.eval_code(code, { max_stack_size: 1024 ** 2 })
+Quickjs.eval_code(code,
+  memory_limit: 1024 ** 3,   # 1GB memory limit
+  max_stack_size: 1024 ** 2, # 1MB max stack size
+)
 ```
 
-#### Toggle features
+#### Timeout
 
 ```rb
-# Enable `std` module by quickjs: https://bellard.org/quickjs/quickjs.html#std-module
-vm = Quickjs.eval_code(features: [::Quickjs::MODULE_STD])
-
-# Enable `os` module by quickjs: https://bellard.org/quickjs/quickjs.html#os-module
-vm = Quickjs.eval_code(features: [::Quickjs::MODULE_OS])
-
-# Provide `setTimeout` managed by CRuby
-vm = Quickjs.eval_code(features: [::Quickjs::FEATURE_TIMEOUT])
+# eval_code will be interrupted after 1 sec (default: 100 msec)
+Quickjs.eval_code(code, timeout_msec: 1_000)
+```
 
-# Inject the polyfill of Intl
-vm = Quickjs.eval_code(features: [::Quickjs::POLYFILL_INTL])
+#### Features
 
-# Inject the polyfill of Blob and File (W3C File API)
-vm = Quickjs.eval_code(features: [::Quickjs::POLYFILL_FILE])
+```rb
+Quickjs.eval_code(code, features: [::Quickjs::MODULE_STD, ::Quickjs::POLYFILL_FILE])
 ```
 
+| Constant | Description |
+|---|---|
+| `MODULE_STD` | QuickJS [`std` module](https://bellard.org/quickjs/quickjs.html#std-module) |
+| `MODULE_OS` | QuickJS [`os` module](https://bellard.org/quickjs/quickjs.html#os-module) |
+| `FEATURE_TIMEOUT` | `setTimeout` / `setInterval` managed by CRuby |
+| `POLYFILL_INTL` | Intl API (DateTimeFormat, NumberFormat, PluralRules, Locale) |
+| `POLYFILL_FILE` | W3C File API (Blob and File) |
+| `POLYFILL_ENCODING` | Encoding API (TextEncoder and TextDecoder) |
+| `POLYFILL_URL` | URL API (URL and URLSearchParams) |
+| `POLYFILL_CRYPTO` | Web Crypto API (`crypto.getRandomValues`, `crypto.randomUUID`, `crypto.subtle`); combine with `POLYFILL_ENCODING` for string↔buffer conversion |
+
 </details>
 
 ### `Quickjs::VM`: Maintain a consistent VM/runtime
 
+Accepts the same [options](#quickjseval_code-evaluate-javascript-code-instantly) as `Quickjs.eval_code`.
+
 ```rb
 vm = Quickjs::VM.new
 vm.eval_code('const a = { b: "c" };')
@@ -80,44 +78,28 @@ vm.eval_code('a.b = "d";')
 vm.eval_code('a.b;') #=> "d"
 ```
 
-<details>
-<summary>Config VM/runtime</summary>
-
-#### Resources
+#### `Quickjs::VM#call`: ⚡ Call a JS function directly with Ruby arguments
 
 ```rb
-vm = Quickjs::VM.new(
-  memory_limit: 1024 ** 3,
-  max_stack_size: 1024 ** 2,
-)
-```
-
-#### Toggle features
-
-```rb
-# Enable `std` module by quickjs: https://bellard.org/quickjs/quickjs.html#std-module
-vm = Quickjs::VM.new(features: [::Quickjs::MODULE_STD])
-
-# Enable `os` module by quickjs: https://bellard.org/quickjs/quickjs.html#os-module
-vm = Quickjs::VM.new(features: [::Quickjs::MODULE_OS])
+vm = Quickjs::VM.new
+vm.eval_code('function add(a, b) { return a + b; }')
 
-# Provide `setTimeout` managed by CRuby
-vm = Quickjs::VM.new(features: [::Quickjs::FEATURE_TIMEOUT])
+vm.call('add', 1, 2)           #=> 3
+vm.call(:add, 1, 2)            #=> 3  (Symbol also works)
 
-# Inject the polyfill of Intl
-vm = Quickjs::VM.new(features: [::Quickjs::POLYFILL_INTL])
+# Nested functions — preserves `this` binding
+vm.eval_code('const counter = { n: 0, inc() { return ++this.n; } }')
+vm.call('counter.inc')         #=> 1
+vm.call('counter.inc')         #=> 2
 
-# Inject the polyfill of Blob and File (W3C File API)
-vm = Quickjs::VM.new(features: [::Quickjs::POLYFILL_FILE])
-```
+# Keys with special characters via bracket notation
+vm.eval_code("const obj = {}; obj['my-fn'] = x => x * 2;")
+vm.call('obj["my-fn"]', 21)    #=> 42
 
-#### VM timeout
-
-```rb
-# `eval_code` will be interrupted after 1 sec (default: 100 msec)
-vm = Quickjs::VM.new(timeout_msec: 1_000)
+# Async functions are automatically awaited
+vm.eval_code('async function fetchVal() { return 42; }')
+vm.call('fetchVal')            #=> 42
 ```
-</details>
 
 #### `Quickjs::VM#import`: 🔌 Import ESM from a source code
 
@@ -151,32 +133,75 @@ end
 vm.eval_code("greetingTo('Rick')") #=> 'Hello! Rick'
 ```
 
-#### `Quickjs::VM#logs`: 💾 Capture console logs
+A Ruby exception raised inside the block is catchable in JS as an `Error`, and propagates back to Ruby as the original exception type if uncaught in JS.
+
+```rb
+vm.define_function("fail") { raise IOError, "something went wrong" }
+
+vm.eval_code('try { fail() } catch (e) { e.message }') #=> "something went wrong"
+vm.eval_code("fail()") #=> raise IOError transparently
+```
 
-All logs by `console.(log|info|debug|warn|error)` on VM are recorded and inspectable.
+With `POLYFILL_FILE` enabled, a Ruby `::File` returned from the block becomes a JS `File`-compatible proxy. Passing it back to Ruby from JS returns the original `::File` object.
+
+```rb
+vm = Quickjs::VM.new(features: [::Quickjs::POLYFILL_FILE])
+vm.define_function(:get_file) { File.open('report.pdf') }
+
+vm.eval_code("get_file().name")          #=> "report.pdf"
+vm.eval_code("get_file().size")          #=> Integer (byte size)
+vm.eval_code("await get_file().text()") #=> file content as String
+```
+
+#### `Quickjs::VM#on_log`: 📡 Handle console logs in real time
+
+Register a block to be called for each `console.(log|info|debug|warn|error)` call.
 
 ```rb
 vm = Quickjs::VM.new
-vm.eval_code('console.log("log me", null)')
+vm.on_log { |log| puts "#{log.severity}: #{log.to_s}" }
 
-vm.logs #=> Array of Quickjs::VM::Log
-vm.logs.last.severity #=> :info
-vm.logs.last.to_s #=> 'log me null'
-vm.logs.last.raw #=> ['log me', nil]
+vm.eval_code('console.log("hello", 42)')
+# => prints: info: hello 42
+
+# log.severity #=> :info / :verbose / :warning / :error
+# log.to_s     #=> space-joined string of all arguments
+# log.raw      #=> Array of raw Ruby values
 ```
 
+### Value Conversion
+
+| JavaScript | | Ruby | Note |
+|---|:---:|---|---|
+| `number` (integer / float) | ↔ | `Integer` / `Float` | |
+| `string` | ↔ | `String` | |
+| `true` / `false` | ↔ | `true` / `false` | |
+| `null` | ↔ | `nil` | |
+| `Array` | ↔ | `Array` | via JSON |
+| `Object` | ↔ | `Hash` | via JSON |
+| `undefined` | → | `Quickjs::Value::UNDEFINED` | |
+| `NaN` | → | `Quickjs::Value::NAN` | |
+| `Blob` | → | `Quickjs::Blob` — `.size`, `.type`, `.content` | requires `POLYFILL_FILE` |
+| `File` | → | `Quickjs::File` — `.name`, `.last_modified` + Blob attrs | requires `POLYFILL_FILE` |
+| `File` proxy | ← | `::File` | requires `POLYFILL_FILE`; applies to `define_function` return values |
+
 ## License
 
 - `ext/quickjsrb/quickjs`
   - [MIT License Copyright (c) 2017-2021 by Fabrice Bellard and Charlie Gordon](https://github.com/bellard/quickjs/blob/6e2e68fd0896957f92eb6c242a2e048c1ef3cae0/LICENSE).
 - `ext/quickjsrb/vendor/polyfill-intl-en.min.js` ([bundled and minified from `polyfills/`](https://github.com/hmsk/quickjs.rb/tree/main/polyfills))
+  - MIT License Copyright (c) 2022 FormatJS
+    - [@formatjs/intl-supportedvaluesof](https://github.com/formatjs/formatjs/blob/main/packages/intl-supportedvaluesof/LICENSE.md)
   - MIT License Copyright (c) 2023 FormatJS
     - [@formatjs/intl-getcanonicallocales](https://github.com/formatjs/formatjs/blob/main/packages/intl-getcanonicallocales/LICENSE.md)
     - [@formatjs/intl-locale](https://github.com/formatjs/formatjs/blob/main/packages/intl-locale/LICENSE.md)
     - [@formatjs/intl-pluralrules](https://github.com/formatjs/formatjs/blob/main/packages/intl-pluralrules/LICENSE.md)
     - [@formatjs/intl-numberformat](https://github.com/formatjs/formatjs/blob/main/packages/intl-numberformat/LICENSE.md)
     - [@formatjs/intl-datetimeformat](https://github.com/formatjs/formatjs/blob/main/packages/intl-datetimeformat/LICENSE.md)
-  - MIT License Copyright (c) 2025 Michael Mclaughlin
-    - [decimal.js](https://www.npmjs.com/package/decimal.js)
+    - [@formatjs/ecma402-abstract](https://github.com/formatjs/formatjs/blob/main/packages/ecma402-abstract/LICENSE.md)
+    - [@formatjs/fast-memoize](https://github.com/formatjs/formatjs/blob/main/packages/fast-memoize/LICENSE.md)
+    - [@formatjs/intl-localematcher](https://github.com/formatjs/formatjs/blob/main/packages/intl-localematcher/LICENSE.md)
+  - MIT License Copyright (c) 2026 FormatJS
+    - [@formatjs/bigdecimal](https://github.com/formatjs/formatjs/blob/main/packages/bigdecimal/LICENSE.md)
 
 Otherwise, [the MIT License, Copyright 2024 by Kengo Hamasaki](/LICENSE).

data/Rakefile

@@ -54,6 +54,13 @@ namespace :polyfills do
     Rake::Task[:compile].invoke
   end
 
+  desc 'Check licenses of bundled polyfill dependencies'
+  task :check_licenses do
+    Dir.chdir(File.expand_path('polyfills', __dir__)) do
+      sh 'npm run check-licenses'
+    end
+  end
+
   namespace :version do
     task :check do
       check_polyfill_version! do |pkg_v, gem_v|

data/ext/quickjsrb/extconf.rb

@@ -14,8 +14,11 @@ $srcs = [
   'polyfill-intl-en.min.c',
   'polyfill-file.min.c',
   'polyfill-encoding.min.c',
+  'polyfill-url.min.c',
   'quickjsrb.c',
   'quickjsrb_file.c',
+  'quickjsrb_crypto.c',
+  'quickjsrb_crypto_subtle.c',
 ]
 
 append_cflags('-I$(srcdir)/quickjs')
@@ -72,6 +75,10 @@ polyfill-encoding.min.js:
 		$(COPY) $(srcdir)/vendor/$@ $@
 polyfill-encoding.min.c: ./qjsc polyfill-encoding.min.js
 		./qjsc -fno-string-normalize -fno-eval -fno-proxy -fno-module-loader -c -M polyfill/encoding.so,encoding -m -o $@ polyfill-encoding.min.js
+polyfill-url.min.js:
+		$(COPY) $(srcdir)/vendor/$@ $@
+polyfill-url.min.c: ./qjsc polyfill-url.min.js
+		./qjsc -fno-string-normalize -fno-eval -fno-proxy -fno-module-loader -c -M polyfill/url.so,url -m -o $@ polyfill-url.min.js
 COMPILE_POLYFILL
   conf
 end

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";
@@ -486,20 +489,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 +677,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 +722,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 +753,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)
@@ -790,6 +798,142 @@ static VALUE vm_m_defineGlobalFunction(int argc, VALUE *argv, VALUE r_self)
   return r_name_sym;
 }
 
+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);
+
+  JSValue j_this = JS_UNDEFINED;
+  JSValue j_func;
+
+  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, '.');
+
+    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");
+  }
+
+  {
+    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]);
+  }
+
+  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)
 {
   VALUE r_import_string, r_opts;
@@ -850,16 +994,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 +1007,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));