mini_racer 0.17.0.pre6 → 0.17.0.pre7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd376af6f7b025e07395d6e1a9c06c83007bc2f8bc7e51abbfd2312605bd0721
-  data.tar.gz: 443568af7a5d3aea76bd354643f32bc39454e818cb9ae86ed4b34214fdd9c612
+  metadata.gz: 1d058a397309a0e5354576fa25b299f26e9ca9576b23333063dbcd46fcf9f775
+  data.tar.gz: 3dde7c0c2e713ebb419593eb6fb0d7634f07ee4d91e35549aa9fb57987a255e5
 SHA512:
-  metadata.gz: b63e0bbd1e8fc79a882f8cbc7b8541a0e4f76d65c824a6cedca617e46f3395af4b409484e558fefa5ef0259bd6b1588a13e44c63131e11472e5fb28ff6f34f88
-  data.tar.gz: 228ad46872d41a852498c7ac204b2b9fa664903e394d915dcdd53852ea3a2053d17818c1b04fa2ff8a40aef9c464c207b3cb72a5b076ba8a7a09a6f6a7f36848
+  metadata.gz: 8cf3e4c85acafb8161ff8a88d193b7bfde7e2b1ab241366364306a72416f462cbd31b4886a3b1f01402557a6045fd6ad40b1837849f307df9d3ac3fafdd7c6d0
+  data.tar.gz: a08db269e750b147daa7501cdf38dccdee8de7d07530b0112aecd1da3949b8daab704c778f1b3657d0dea328b087db9173f30e9aeb43f9d755d4a95dd1e51bac

data/CHANGELOG

@@ -1,3 +1,8 @@
+- 0.17.0.pre7 - 10-01-2025
+
+  - Objects containing non serializable properties will return an Error object vs raising an exception. Ben Noordhuis
+  - Truffle support was added back Eregon
+
 - 0.17.0.pre6 - 08-01-2025
 
   - Moved all mini_racer interaction with v8 to a dedicated native thread to avoid cross VM stack contamination. Ben Noordhuis

data/README.md

@@ -206,58 +206,27 @@ context.eval("counter")
 # => 1
 ```
 
-### Shared isolates
+### Garbage collection
 
-By default, MiniRacer's contexts each have their own isolate (V8 runtime). For efficiency, it is possible to re-use an isolate across contexts:
+Re-using the same context over and over again means V8's garbage collector will have to run to clean it up every now and then; it's possible to trigger a _blocking_ V8 GC run inside your context by running the `idle_notification` method on it, which takes a single argument: the amount of time (in milliseconds) that V8 should use at most for garbage collecting:
 
 ```ruby
-isolate = MiniRacer::Isolate.new
-
-context1 = MiniRacer::Context.new(isolate: isolate)
-context2 = MiniRacer::Context.new(isolate: isolate)
-
-context1.isolate == context2.isolate
-# => true
-```
-
-The main benefit of this is avoiding creating/destroying isolates when not needed (for example if you use a lot of contexts).
-
-The caveat with this is that a given isolate can only execute one context at a time, so don't share isolates across contexts that you want to run concurrently.
-
-Also, note that if you want to use shared isolates together with snapshots, you need to first create an isolate with that snapshot, and then create contexts from that isolate:
-
-```ruby
-snapshot = MiniRacer::Snapshot.new("function hello() { return 'world!'; }")
-
-isolate = MiniRacer::Isolate.new(snapshot)
-
-context = MiniRacer::Context.new(isolate: isolate)
-
-context.eval("hello()")
-# => "world!"
-```
-
-Re-using the same isolate over and over again means V8's garbage collector will have to run to clean it up every now and then; it's possible to trigger a _blocking_ V8 GC run inside your isolate by running the `idle_notification` method on it, which takes a single argument: the amount of time (in milliseconds) that V8 should use at most for garbage collecting:
-
-```ruby
-isolate = MiniRacer::Isolate.new
-
-context = MiniRacer::Context.new(isolate: isolate)
+context = MiniRacer::Context.new
 
 # do stuff with that context...
 
 # give up to 100ms for V8 garbage collection
-isolate.idle_notification(100)
+context.idle_notification(100)
 
 # force V8 to perform a full GC
-isolate.low_memory_notification
+context.low_memory_notification
 ```
 
 This can come in handy to force V8 GC runs for example in between requests if you use MiniRacer on a web application.
 
 Note that this method maps directly to [`v8::Isolate::IdleNotification`](http://bespin.cz/~ondras/html/classv8_1_1Isolate.html#aea16cbb2e351de9a3ae7be2b7cb48297), and that in particular its return value is the same (true if there is no further garbage to collect, false otherwise) and the same caveats apply, in particular that `there is no guarantee that the [call will return] within the time limit.`
 
-Additionally you may automate this process on a context by defining it with `MiniRacer::Content.new(ensure_gc_after_idle: 1000)`. Using this will ensure V8 will run a full GC using `context.isolate.low_memory_notification` 1 second after the last eval on the context. Low memory notification is both slower and more aggressive than an idle_notification and will ensure long living isolates use minimal amounts of memory.
+Additionally you may automate this process on a context by defining it with `MiniRacer::Context.new(ensure_gc_after_idle: 1000)`. Using this will ensure V8 will run a full GC using `context.low_memory_notification` 1 second after the last eval on the context. Low memory notification is both slower and more aggressive than an idle_notification and will ensure long living contexts use minimal amounts of memory.
 
 ### V8 Runtime flags
 
@@ -301,7 +270,7 @@ Please refer to http://node.green/ as a reference on other harmony features.
 
 A list of all V8 runtime flags can be found using `node --v8-options`, or else by perusing [the V8 source code for flags (make sure to use the right version of V8)](https://github.com/v8/v8/blob/master/src/flags/flag-definitions.h).
 
-Note that runtime flags must be set before any other operation (e.g. creating a context, a snapshot or an isolate), otherwise an exception will be thrown.
+Note that runtime flags must be set before any other operation (e.g. creating a context or a snapshot), otherwise an exception will be thrown.
 
 Flags:
 

data/ext/mini_racer_extension/mini_racer_v8.cc

@@ -34,8 +34,6 @@ struct State
     v8::Local<v8::Context> safe_context;
     v8::Persistent<v8::Context> persistent_context;      // single-thread mode only
     v8::Persistent<v8::Context> persistent_safe_context; // single-thread mode only
-    v8::Persistent<v8::Object> persistent_webassembly_instance;
-    v8::Local<v8::Object> webassembly_instance;
     Context *ruby_context;
     int64_t max_memory;
     int err_reason;
@@ -81,21 +79,54 @@ bool reply(State& st, v8::Local<v8::Value> v)
     return serialized.data != nullptr; // exception pending if false
 }
 
+bool reply(State& st, v8::Local<v8::Value> result, v8::Local<v8::Value> err)
+{
+    v8::TryCatch try_catch(st.isolate);
+    try_catch.SetVerbose(st.verbose_exceptions);
+    v8::Local<v8::Array> response;
+    {
+        v8::Context::Scope context_scope(st.safe_context);
+        response = v8::Array::New(st.isolate, 2);
+    }
+    response->Set(st.context, 0, result).Check();
+    response->Set(st.context, 1, err).Check();
+    if (reply(st, response)) return true;
+    if (!try_catch.CanContinue()) { // termination exception?
+        try_catch.ReThrow();
+        return false;
+    }
+    v8::String::Utf8Value s(st.isolate, try_catch.Exception());
+    const char *message = *s ? *s : "unexpected failure";
+    // most serialization errors will be DataCloneErrors but not always
+    // DataCloneErrors are not directly detectable so use a heuristic
+    if (!strstr(message, "could not be cloned")) {
+        try_catch.ReThrow();
+        return false;
+    }
+    // return an {"error": "foo could not be cloned"} object
+    v8::Local<v8::Object> error;
+    {
+        v8::Context::Scope context_scope(st.safe_context);
+        error = v8::Object::New(st.isolate);
+    }
+    auto key = v8::String::NewFromUtf8Literal(st.isolate, "error");
+    v8::Local<v8::String> val;
+    if (!v8::String::NewFromUtf8(st.isolate, message).ToLocal(&val)) {
+        val = v8::String::NewFromUtf8Literal(st.isolate, "unexpected error");
+    }
+    error->Set(st.context, key, val).Check();
+    response->Set(st.context, 0, error).Check();
+    if (!reply(st, response)) {
+        try_catch.ReThrow();
+        return false;
+    }
+    return true;
+}
+
 v8::Local<v8::Value> sanitize(State& st, v8::Local<v8::Value> v)
 {
     // punch through proxies
     while (v->IsProxy()) v = v8::Proxy::Cast(*v)->GetTarget();
-    // things that cannot be serialized
-    if (v->IsArgumentsObject() ||
-        v->IsPromise() ||
-        v->IsModule() ||
-        v->IsModuleNamespaceObject() ||
-        v->IsWasmMemoryObject() ||
-        v->IsWasmModuleObject() ||
-        v->IsWasmNull() ||
-        v->IsWeakRef()) {
-        return v8::Object::New(st.isolate);
-    }
     // V8's serializer doesn't accept symbols
     if (v->IsSymbol()) return v8::Symbol::Cast(*v)->Description(st.isolate);
     // TODO(bnoordhuis) replace this hack with something more principled
@@ -111,17 +142,10 @@ v8::Local<v8::Value> sanitize(State& st, v8::Local<v8::Value> v)
             return array;
         }
     }
-    // WebAssembly.Instance objects are not serializable but there
-    // is no direct way to detect them through the V8 C++ API
-    if (!st.webassembly_instance.IsEmpty() &&
-        v->IsObject() &&
-        v->InstanceOf(st.context, st.webassembly_instance).FromMaybe(false)) {
-        return v8::Object::New(st.isolate);
-    }
     return v;
 }
 
-v8::Local<v8::Value> to_error(State& st, v8::TryCatch *try_catch, int cause)
+v8::Local<v8::String> to_error(State& st, v8::TryCatch *try_catch, int cause)
 {
     v8::Local<v8::Value> t;
     char buf[1024];
@@ -216,18 +240,7 @@ extern "C" State *v8_thread_init(Context *c, const uint8_t *snapshot_buf,
         st.safe_context = v8::Context::New(st.isolate);
         st.context = v8::Context::New(st.isolate);
         v8::Context::Scope context_scope(st.context);
-        auto global = st.context->Global();
-        // globalThis.WebAssembly is missing in --jitless mode
-        auto key = v8::String::NewFromUtf8Literal(st.isolate, "WebAssembly");
-        v8::Local<v8::Value> wasm_v;
-        if (global->Get(st.context, key).ToLocal(&wasm_v) && wasm_v->IsObject()) {
-            auto key = v8::String::NewFromUtf8Literal(st.isolate, "Instance");
-            st.webassembly_instance =
-                wasm_v.As<v8::Object>()
-                ->Get(st.context, key).ToLocalChecked().As<v8::Object>();
-        }
         if (single_threaded) {
-            st.persistent_webassembly_instance.Reset(st.isolate, st.webassembly_instance);
             st.persistent_safe_context.Reset(st.isolate, st.safe_context);
             st.persistent_context.Reset(st.isolate, st.context);
             return pst; // intentionally returning early and keeping alive
@@ -246,7 +259,7 @@ void v8_api_callback(const v8::FunctionCallbackInfo<v8::Value>& info)
     v8::Local<v8::Array> request;
     {
         v8::Context::Scope context_scope(st.safe_context);
-        request = v8::Array::New(st.isolate, 2);
+        request = v8::Array::New(st.isolate, 1 + info.Length());
     }
     for (int i = 0, n = info.Length(); i < n; i++) {
         request->Set(st.context, i, sanitize(st, info[i])).Check();
@@ -354,11 +367,6 @@ extern "C" void v8_call(State *pst, const uint8_t *p, size_t n)
     v8::ValueDeserializer des(st.isolate, p, n);
     std::vector<v8::Local<v8::Value>> args;
     des.ReadHeader(st.context).Check();
-    v8::Local<v8::Array> response;
-    {
-        v8::Context::Scope context_scope(st.safe_context);
-        response = v8::Array::New(st.isolate, 2);
-    }
     v8::Local<v8::Value> result;
     int cause = INTERNAL_ERROR;
     {
@@ -420,9 +428,7 @@ fail:
     if (!cause && try_catch.HasCaught()) cause = RUNTIME_ERROR;
     if (cause) result = v8::Undefined(st.isolate);
     auto err = to_error(st, &try_catch, cause);
-    response->Set(st.context, 0, result).Check();
-    response->Set(st.context, 1, err).Check();
-    if (!reply(st, response)) {
+    if (!reply(st, result, err)) {
         assert(try_catch.HasCaught());
         goto fail; // retry; can be termination exception
     }
@@ -437,11 +443,6 @@ extern "C" void v8_eval(State *pst, const uint8_t *p, size_t n)
     v8::HandleScope handle_scope(st.isolate);
     v8::ValueDeserializer des(st.isolate, p, n);
     des.ReadHeader(st.context).Check();
-    v8::Local<v8::Array> response;
-    {
-        v8::Context::Scope context_scope(st.safe_context);
-        response = v8::Array::New(st.isolate, 2);
-    }
     v8::Local<v8::Value> result;
     int cause = INTERNAL_ERROR;
     {
@@ -475,9 +476,7 @@ fail:
     if (!cause && try_catch.HasCaught()) cause = RUNTIME_ERROR;
     if (cause) result = v8::Undefined(st.isolate);
     auto err = to_error(st, &try_catch, cause);
-    response->Set(st.context, 0, result).Check();
-    response->Set(st.context, 1, err).Check();
-    if (!reply(st, response)) {
+    if (!reply(st, result, err)) {
         assert(try_catch.HasCaught());
         goto fail; // retry; can be termination exception
     }
@@ -638,11 +637,6 @@ extern "C" void v8_snapshot(State *pst, const uint8_t *p, size_t n)
     v8::HandleScope handle_scope(st.isolate);
     v8::ValueDeserializer des(st.isolate, p, n);
     des.ReadHeader(st.context).Check();
-    v8::Local<v8::Array> response;
-    {
-        v8::Context::Scope context_scope(st.safe_context);
-        response = v8::Array::New(st.isolate, 2);
-    }
     v8::Local<v8::Value> result;
     v8::StartupData blob{nullptr, 0};
     int cause = INTERNAL_ERROR;
@@ -682,9 +676,7 @@ fail:
     } else {
         err = to_error(st, &try_catch, cause);
     }
-    response->Set(st.context, 0, result).Check();
-    response->Set(st.context, 1, err).Check();
-    if (!reply(st, response)) {
+    if (!reply(st, result, err)) {
         assert(try_catch.HasCaught());
         goto fail; // retry; can be termination exception
     }
@@ -699,11 +691,6 @@ extern "C" void v8_warmup(State *pst, const uint8_t *p, size_t n)
     std::vector<uint8_t> storage;
     v8::ValueDeserializer des(st.isolate, p, n);
     des.ReadHeader(st.context).Check();
-    v8::Local<v8::Array> response;
-    {
-        v8::Context::Scope context_scope(st.safe_context);
-        response = v8::Array::New(st.isolate, 2);
-    }
     v8::Local<v8::Value> result;
     v8::StartupData blob{nullptr, 0};
     int cause = INTERNAL_ERROR;
@@ -761,9 +748,7 @@ fail:
     } else {
         err = to_error(st, &try_catch, cause);
     }
-    response->Set(st.context, 0, result).Check();
-    response->Set(st.context, 1, err).Check();
-    if (!reply(st, response)) {
+    if (!reply(st, result, err)) {
         assert(try_catch.HasCaught());
         goto fail; // retry; can be termination exception
     }
@@ -807,14 +792,12 @@ extern "C" void v8_single_threaded_enter(State *pst, Context *c, void (*f)(Conte
     v8::Isolate::Scope isolate_scope(st.isolate);
     v8::HandleScope handle_scope(st.isolate);
     {
-        st.webassembly_instance = v8::Local<v8::Object>::New(st.isolate, st.persistent_webassembly_instance);
         st.safe_context = v8::Local<v8::Context>::New(st.isolate, st.persistent_safe_context);
         st.context = v8::Local<v8::Context>::New(st.isolate, st.persistent_context);
         v8::Context::Scope context_scope(st.context);
         f(c);
         st.context = v8::Local<v8::Context>();
         st.safe_context = v8::Local<v8::Context>();
-        st.webassembly_instance = v8::Local<v8::Object>();
     }
 }
 
@@ -830,7 +813,6 @@ State::~State()
     {
         v8::Locker locker(isolate);
         v8::Isolate::Scope isolate_scope(isolate);
-        persistent_webassembly_instance.Reset();
         persistent_safe_context.Reset();
         persistent_context.Reset();
     }

data/lib/mini_racer/shared.rb

@@ -0,0 +1,380 @@
+# This code used to be shared in lib/mini_racer.rb
+# but was moved to the extension with https://github.com/rubyjs/mini_racer/pull/325.
+# So now this is effectively duplicate logic with C/C++ code.
+# Maybe one day it can be actually shared again between both backends.
+
+module MiniRacer
+
+  MARSHAL_STACKDEPTH_DEFAULT = 2**9-2
+  MARSHAL_STACKDEPTH_MAX_VALUE = 2**10-2
+
+  class FailedV8Conversion
+    attr_reader :info
+    def initialize(info)
+      @info = info
+    end
+  end
+
+  # helper class returned when we have a JavaScript function
+  class JavaScriptFunction
+    def to_s
+      "JavaScript Function"
+    end
+  end
+
+  class Isolate
+    def initialize(snapshot = nil)
+      unless snapshot.nil? || snapshot.is_a?(Snapshot)
+        raise ArgumentError, "snapshot must be a Snapshot object, passed a #{snapshot.inspect}"
+      end
+
+      # defined in the C class
+      init_with_snapshot(snapshot)
+    end
+  end
+
+  class Platform
+    class << self
+      def set_flags!(*args, **kwargs)
+        flags_to_strings([args, kwargs]).each do |flag|
+          # defined in the C class
+          set_flag_as_str!(flag)
+        end
+      end
+
+      private
+
+      def flags_to_strings(flags)
+        flags.flatten.map { |flag| flag_to_string(flag) }.flatten
+      end
+
+      # normalize flags to strings, and adds leading dashes if needed
+      def flag_to_string(flag)
+        if flag.is_a?(Hash)
+          flag.map do |key, value|
+            "#{flag_to_string(key)} #{value}"
+          end
+        else
+          str = flag.to_s
+          str = "--#{str}" unless str.start_with?('--')
+          str
+        end
+      end
+    end
+  end
+
+  # eval is defined in the C class
+  class Context
+
+    class ExternalFunction
+      def initialize(name, callback, parent)
+        unless String === name
+          raise ArgumentError, "parent_object must be a String"
+        end
+        parent_object, _ , @name = name.rpartition(".")
+        @callback = callback
+        @parent = parent
+        @parent_object_eval = nil
+        @parent_object = nil
+
+        unless parent_object.empty?
+          @parent_object = parent_object
+
+          @parent_object_eval = ""
+          prev = ""
+          first = true
+          parent_object.split(".").each do |obj|
+            prev << obj
+            if first
+              @parent_object_eval << "if (typeof #{prev} !== 'object' || typeof #{prev} !== 'function') { #{prev} = {} };\n"
+            else
+              @parent_object_eval << "#{prev} = #{prev} || {};\n"
+            end
+            prev << "."
+            first = false
+          end
+          @parent_object_eval << "#{parent_object};"
+        end
+        notify_v8
+      end
+    end
+
+    def initialize(max_memory: nil, timeout: nil, isolate: nil, ensure_gc_after_idle: nil, snapshot: nil, marshal_stack_depth: nil)
+      options ||= {}
+
+      check_init_options!(isolate: isolate, snapshot: snapshot, max_memory: max_memory, marshal_stack_depth: marshal_stack_depth, ensure_gc_after_idle: ensure_gc_after_idle, timeout: timeout)
+
+      @functions = {}
+      @timeout = nil
+      @max_memory = nil
+      @current_exception = nil
+      @timeout = timeout
+      @max_memory = max_memory
+      @marshal_stack_depth = marshal_stack_depth
+
+      # false signals it should be fetched if requested
+      @isolate = isolate || false
+
+      @ensure_gc_after_idle = ensure_gc_after_idle
+
+      if @ensure_gc_after_idle
+        @last_eval = nil
+        @ensure_gc_thread = nil
+        @ensure_gc_mutex = Mutex.new
+      end
+
+      @disposed = false
+
+      @callback_mutex = Mutex.new
+      @callback_running = false
+      @thread_raise_called = false
+      @eval_thread = nil
+
+      # defined in the C class
+      init_unsafe(isolate, snapshot)
+    end
+
+    def isolate
+      return @isolate if @isolate != false
+      # defined in the C class
+      @isolate = create_isolate_value
+    end
+
+    def eval(str, options=nil)
+      raise(ContextDisposedError, 'attempted to call eval on a disposed context!') if @disposed
+
+      filename = options && options[:filename].to_s
+
+      @eval_thread = Thread.current
+      isolate_mutex.synchronize do
+        @current_exception = nil
+        timeout do
+          eval_unsafe(str, filename)
+        end
+      end
+    ensure
+      @eval_thread = nil
+      ensure_gc_thread if @ensure_gc_after_idle
+    end
+
+    def call(function_name, *arguments)
+      raise(ContextDisposedError, 'attempted to call function on a disposed context!') if @disposed
+
+      @eval_thread = Thread.current
+      isolate_mutex.synchronize do
+        timeout do
+          call_unsafe(function_name, *arguments)
+        end
+      end
+    ensure
+      @eval_thread = nil
+      ensure_gc_thread if @ensure_gc_after_idle
+    end
+
+    def dispose
+      return if @disposed
+      isolate_mutex.synchronize do
+        return if @disposed
+        dispose_unsafe
+        @disposed = true
+        @isolate = nil # allow it to be garbage collected, if set
+      end
+    end
+
+
+    def attach(name, callback)
+      raise(ContextDisposedError, 'attempted to call function on a disposed context!') if @disposed
+
+      wrapped = lambda do |*args|
+        begin
+
+          r = nil
+
+          begin
+            @callback_mutex.synchronize{
+              @callback_running = true
+            }
+            r = callback.call(*args)
+          ensure
+            @callback_mutex.synchronize{
+              @callback_running = false
+            }
+          end
+
+          # wait up to 2 seconds for this to be interrupted
+          # will very rarely be called cause #raise is called
+          # in another mutex
+          @callback_mutex.synchronize {
+            if @thread_raise_called
+              sleep 2
+            end
+          }
+
+          r
+
+        ensure
+          @callback_mutex.synchronize {
+            @thread_raise_called = false
+          }
+        end
+      end
+
+      isolate_mutex.synchronize do
+        external = ExternalFunction.new(name, wrapped, self)
+        @functions["#{name}"] = external
+      end
+    end
+
+    private
+
+    def ensure_gc_thread
+      @last_eval = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      @ensure_gc_mutex.synchronize do
+        @ensure_gc_thread = nil if !@ensure_gc_thread&.alive?
+        return if !Thread.main.alive? # avoid "can't alloc thread" exception
+        @ensure_gc_thread ||= Thread.new do
+          ensure_gc_after_idle_seconds = @ensure_gc_after_idle / 1000.0
+          done = false
+          while !done
+            now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+            if @disposed
+              @ensure_gc_thread = nil
+              break
+            end
+
+            if !@eval_thread && ensure_gc_after_idle_seconds < now - @last_eval
+              @ensure_gc_mutex.synchronize do
+                isolate_mutex.synchronize do
+                  if !@eval_thread
+                    low_memory_notification if !@disposed
+                    @ensure_gc_thread = nil
+                    done = true
+                  end
+                end
+              end
+            end
+            sleep ensure_gc_after_idle_seconds if !done
+          end
+        end
+      end
+    end
+
+    def stop_attached
+      @callback_mutex.synchronize{
+        if @callback_running
+          @eval_thread.raise ScriptTerminatedError, "Terminated during callback"
+          @thread_raise_called = true
+        end
+      }
+    end
+
+    def timeout(&blk)
+      return blk.call unless @timeout
+
+      mutex = Mutex.new
+      done = false
+
+      rp,wp = IO.pipe
+
+      t = Thread.new do
+        begin
+          result = rp.wait_readable(@timeout/1000.0)
+          if !result
+            mutex.synchronize do
+              stop unless done
+            end
+          end
+        rescue => e
+          STDERR.puts e
+          STDERR.puts "FAILED TO TERMINATE DUE TO TIMEOUT"
+        end
+      end
+
+      rval = blk.call
+      mutex.synchronize do
+        done = true
+      end
+
+      wp.close
+
+      # ensure we do not leak a thread in state
+      t.join
+      t = nil
+
+      rval
+    ensure
+      # exceptions need to be handled
+      wp&.close
+      t&.join
+      rp&.close
+    end
+
+    def check_init_options!(isolate:, snapshot:, max_memory:, marshal_stack_depth:, ensure_gc_after_idle:, timeout:)
+      assert_option_is_nil_or_a('isolate', isolate, Isolate)
+      assert_option_is_nil_or_a('snapshot', snapshot, Snapshot)
+
+      assert_numeric_or_nil('max_memory', max_memory, min_value: 10_000, max_value: 2**32-1)
+      assert_numeric_or_nil('marshal_stack_depth', marshal_stack_depth, min_value: 1, max_value: MARSHAL_STACKDEPTH_MAX_VALUE)
+      assert_numeric_or_nil('ensure_gc_after_idle', ensure_gc_after_idle, min_value: 1)
+      assert_numeric_or_nil('timeout', timeout, min_value: 1)
+
+      if isolate && snapshot
+        raise ArgumentError, 'can only pass one of isolate and snapshot options'
+      end
+    end
+
+    def assert_numeric_or_nil(option_name, object, min_value:, max_value: nil)
+      if max_value && object.is_a?(Numeric) && object > max_value
+        raise ArgumentError, "#{option_name} must be less than or equal to #{max_value}"
+      end
+
+      if object.is_a?(Numeric) && object < min_value
+        raise ArgumentError, "#{option_name} must be larger than or equal to #{min_value}"
+      end
+
+      if !object.nil? && !object.is_a?(Numeric)
+        raise ArgumentError, "#{option_name} must be a number, passed a #{object.inspect}"
+      end
+    end
+
+    def assert_option_is_nil_or_a(option_name, object, klass)
+      unless object.nil? || object.is_a?(klass)
+        raise ArgumentError, "#{option_name} must be a #{klass} object, passed a #{object.inspect}"
+      end
+    end
+  end
+
+  # `size` and `warmup!` public methods are defined in the C class
+  class Snapshot
+    def initialize(str = '')
+      # ensure it first can load
+      begin
+        ctx = MiniRacer::Context.new
+        ctx.eval(str)
+      rescue MiniRacer::RuntimeError => e
+        raise MiniRacer::SnapshotError, e.message, e.backtrace
+      end
+
+      @source = str
+
+      # defined in the C class
+      load(str)
+    end
+
+    def warmup!(src)
+      # we have to do something here
+      # we are bloating memory a bit but it is more correct
+      # than hitting an exception when attempty to compile invalid source
+      begin
+        ctx = MiniRacer::Context.new
+        ctx.eval(@source)
+        ctx.eval(src)
+      rescue MiniRacer::RuntimeError => e
+        raise MiniRacer::SnapshotError, e.message, e.backtrace
+      end
+
+      warmup_unsafe!(src)
+    end
+  end
+end

data/lib/mini_racer/truffleruby.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'shared'
+
 module MiniRacer
 
   class Context
@@ -43,6 +45,7 @@ module MiniRacer
     end
 
     def heap_stats
+      raise ContextDisposedError if @disposed
       {
         total_physical_size: 0,
         total_heap_size_executable: 0,
@@ -60,6 +63,14 @@ module MiniRacer
       end
     end
 
+    def low_memory_notification
+      GC.start
+    end
+
+    def idle_notification(idle_time)
+      true
+    end
+
     private
 
     @context_initialized = false
@@ -95,9 +106,11 @@ module MiniRacer
       else
         @snapshot = nil
       end
-      @is_object_or_array_func, @is_time_func, @js_date_to_time_func, @is_symbol_func, @js_symbol_to_symbol_func, @js_new_date_func, @js_new_array_func = eval_in_context <<-CODE
+      @is_object_or_array_func, @is_map_func, @is_map_iterator_func, @is_time_func, @js_date_to_time_func, @is_symbol_func, @js_symbol_to_symbol_func, @js_new_date_func, @js_new_array_func = eval_in_context <<-CODE
         [
           (x) => { return (x instanceof Object || x instanceof Array) && !(x instanceof Date) && !(x instanceof Function) },
+          (x) => { return x instanceof Map },
+          (x) => { return x[Symbol.toStringTag] === 'Map Iterator' },
           (x) => { return x instanceof Date },
           (x) => { return x.getTime(x) },
           (x) => { return typeof x === 'symbol' },
@@ -233,6 +246,10 @@ module MiniRacer
           js_date_to_time(value)
         elsif symbol?(value)
           js_symbol_to_symbol(value)
+        elsif map?(value)
+          js_map_to_hash(value)
+        elsif map_iterator?(value)
+          value.map { |e| convert_js_to_ruby(e) }
         else
           object = value
           h = {}
@@ -251,6 +268,14 @@ module MiniRacer
       @is_object_or_array_func.call(val)
     end
 
+    def map?(value)
+      @is_map_func.call(value)
+    end
+
+    def map_iterator?(value)
+      @is_map_iterator_func.call(value)
+    end
+
     def time?(value)
       @is_time_func.call(value)
     end
@@ -268,6 +293,12 @@ module MiniRacer
       @js_symbol_to_symbol_func.call(value).to_s.to_sym
     end
 
+    def js_map_to_hash(map)
+      map.to_a.to_h do |key, value|
+        [convert_js_to_ruby(key), convert_js_to_ruby(value)]
+      end
+    end
+
     def js_new_date(value)
       @js_new_date_func.call(value)
     end
@@ -320,48 +351,13 @@ module MiniRacer
       # However, isolate can hold a snapshot, and code and ASTs are shared between contexts.
       @snapshot = snapshot
     end
-
-    def low_memory_notification
-      GC.start
-    end
-
-    def idle_notification(idle_time)
-      true
-    end
   end
 
   class Platform
-    class << self
-      def set_flags!(*args, **kwargs)
-        flags_to_strings([args, kwargs]).each do |flag|
-          set_flag_as_str!(flag)
-        end
-      end
-
-    private
-
-      def flags_to_strings(flags)
-        flags.flatten.map { |flag| flag_to_string(flag) }.flatten
-      end
-
-      # normalize flags to strings, and adds leading dashes if needed
-      def flag_to_string(flag)
-        if flag.is_a?(Hash)
-          flag.map do |key, value|
-            "#{flag_to_string(key)} #{value}"
-          end
-        else
-          str = flag.to_s
-          str = "--#{str}" unless str.start_with?('--')
-          str
-        end
-      end
-
-      def set_flag_as_str!(flag)
-        raise TypeError, "wrong type argument #{flag.class} (should be a string)" unless flag.is_a?(String)
-        raise MiniRacer::PlatformAlreadyInitialized, "The platform is already initialized." if Context.instance_variable_get(:@context_initialized)
-        Context.instance_variable_set(:@use_strict, true) if "--use_strict" == flag
-      end
+    def self.set_flag_as_str!(flag)
+      raise TypeError, "wrong type argument #{flag.class} (should be a string)" unless flag.is_a?(String)
+      raise MiniRacer::PlatformAlreadyInitialized, "The platform is already initialized." if Context.instance_variable_get(:@context_initialized)
+      Context.instance_variable_set(:@use_strict, true) if "--use_strict" == flag
     end
   end
 

data/lib/mini_racer/version.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module MiniRacer
-  VERSION = "0.17.0.pre6"
+  VERSION = "0.17.0.pre7"
   LIBV8_NODE_VERSION = "~> 22.7.0.4"
 end

data/lib/mini_racer.rb

@@ -75,14 +75,12 @@ module MiniRacer
 
       if String === file_or_io
         f = File.open(file_or_io, "w")
-	implicit = true
+        implicit = true
       else
         f = file_or_io
       end
 
-      if !(File === f)
-        raise ArgumentError, "file_or_io"
-      end
+      raise ArgumentError, "file_or_io" unless File === f
 
       f.write(heap_snapshot())
     ensure

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mini_racer
 version: !ruby/object:Gem::Version
-  version: 0.17.0.pre6
+  version: 0.17.0.pre7
 platform: ruby
 authors:
 - Sam Saffron
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-01-08 00:00:00.000000000 Z
+date: 2025-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -115,6 +115,7 @@ files:
 - ext/mini_racer_loader/extconf.rb
 - ext/mini_racer_loader/mini_racer_loader.c
 - lib/mini_racer.rb
+- lib/mini_racer/shared.rb
 - lib/mini_racer/truffleruby.rb
 - lib/mini_racer/version.rb
 homepage: https://github.com/discourse/mini_racer
@@ -122,9 +123,9 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/discourse/mini_racer/issues
-  changelog_uri: https://github.com/discourse/mini_racer/blob/v0.17.0.pre6/CHANGELOG
-  documentation_uri: https://www.rubydoc.info/gems/mini_racer/0.17.0.pre6
-  source_code_uri: https://github.com/discourse/mini_racer/tree/v0.17.0.pre6
+  changelog_uri: https://github.com/discourse/mini_racer/blob/v0.17.0.pre7/CHANGELOG
+  documentation_uri: https://www.rubydoc.info/gems/mini_racer/0.17.0.pre7
+  source_code_uri: https://github.com/discourse/mini_racer/tree/v0.17.0.pre7
 post_install_message:
 rdoc_options: []
 require_paths: