quickjs 0.11.2 → 0.13.0.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 29ad9419055f853b82d642f0c5404d24d476dcc3d0d8e7da4364f06a819b10a3
-  data.tar.gz: 77b07d4c214663c8fd716ab2c9dda3d88c327f3f77b0d350f2987d506a70677e
+  metadata.gz: f27d3afc594731cc4df53661889a9787626121923ece35c544b581ef3f52722c
+  data.tar.gz: d3869683f9134339d1d2e44617845f8ece614e1503926841fb9d4ad6de3dc7ba
 SHA512:
-  metadata.gz: 75ba55882ce0d5371e3ba3d584849d012c06a955d230e7b9975266852753dae3db45244fc8b9bf967f86ba25fff52d7c6d8118bab131f9e8b61bb421356597c0
-  data.tar.gz: 97964de7f1ef9f20c548cc8e69da09fe058112193593bb433e8b93e3e42424582f111a306df13df78dd583442dd712bc71e6da8ff0ce17116f19618f8aa803d2
+  metadata.gz: b5cfcad98315e8821644aa233ea86213f855900506767ccce01cb0c1a653326456e3d00c453d0821117e31eee543ec440ed1e4583dd6b420a62e49ffcb53e080
+  data.tar.gz: 7df6cc20b91fce4c14e2a2b96b31bb447ee50eba03498a99e336c8b35d62164a05874ed7753509a4d0c1958761f96c5c85f4de66c6301b79eecbe208dbcf8212

data/CLAUDE.md

@@ -0,0 +1,62 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+quickjs.rb is a Ruby gem wrapping QuickJS (a lightweight JavaScript interpreter) via a C extension. It lets Ruby programs evaluate JavaScript code without a full Node.js runtime.
+
+## Build & Test Commands
+
+```bash
+bundle exec rake              # Full cycle: clobber → compile → test
+bundle exec rake compile      # Compile C extension only
+bundle exec rake test         # Run all tests
+bundle exec ruby -Itest:lib test/quickjs_test.rb              # Run single test file
+bundle exec ruby -Itest:lib test/quickjs_test.rb -n test_name # Run single test
+rake polyfills:build          # Rebuild Intl polyfill bundle (requires npm)
+```
+
+QuickJS source lives as a git submodule under `ext/quickjsrb/quickjs/` — clone with `--recurse-submodules`.
+
+## Design Principles
+
+- **Never modify QuickJS core** — the engine is a git submodule; all customization is implemented externally in our C extension or Ruby layer
+- **Prefer Ruby over C** — don't rush to write C code; use Ruby where it provides better extendability and maintainability
+- **Security-conscious C layer** — avoid adding flexible C-level features that introduce security risks; expose QuickJS's own options as-is rather than inventing new attack surface
+- **Keep the default footprint small** — don't increase bundle size or add JavaScript overhead (e.g. polyfills) by default; additional capabilities should be opt-in via feature flags
+
+## Architecture
+
+**C Extension** (`ext/quickjsrb/`):
+- `quickjsrb.c` / `quickjsrb.h` — Core extension: creates QuickJS runtime/context, handles Ruby↔JS value conversion, timeout interrupts, and Ruby function bridging into JS
+- Value conversion uses JSON serialization for complex types (objects/arrays); direct conversion for primitives
+- `VMData` struct holds the JS context, defined Ruby functions, timeout state, console logs, and error references
+- Ruby GC integration via `vm_mark`, `vm_free`, `vm_compact` callbacks
+
+**Ruby layer** (`lib/quickjs/`):
+- `Quickjs::VM` — Persistent JS runtime with `eval_code`, `import`, `define_function`
+- `Quickjs.eval_code` — Convenience method for one-shot evaluation
+- Exception hierarchy maps JS error types (SyntaxError, TypeError, etc.) to Ruby classes under `Quickjs::`
+- Special values: `Quickjs::Value::UNDEFINED` and `Quickjs::Value::NAN` represent JS undefined/NaN
+
+**Feature flags** (passed to `VM.new` via `features:` array):
+- `:feature_std`, `:feature_os` — QuickJS std/os modules
+- `:feature_timeout` — setTimeout/setInterval via CRuby threads
+- `:feature_polyfill_intl` — Intl API polyfill (DateTimeFormat, NumberFormat, PluralRules, Locale)
+
+**Polyfills** (`polyfills/`):
+- Built from FormatJS packages via rolldown, output minified JS embedded as C source
+- Polyfill version must match gem version (enforced during `rake release`)
+
+## Testing
+
+Tests use minitest with `describe`/`it` blocks. Key test files:
+- `test/quickjs_test.rb` — Main test suite (value conversion, errors, VM features, ESM imports, function definitions)
+- `test/quickjs_polyfill_test.rb` — Intl polyfill tests
+
+## Build Notes
+
+- `extconf.rb` compiles with `-DNDEBUG` to avoid conflicts with Ruby 4.0 GC assertions
+- Symbol visibility is hidden by default (`-fvisibility=hidden`)
+- CI matrix: Ruby 3.2/3.3/3.4/4.0 × Ubuntu/macOS

data/README.md

@@ -63,6 +63,9 @@ vm = Quickjs.eval_code(features: [::Quickjs::FEATURE_TIMEOUT])
 
 # Inject the polyfill of Intl
 vm = Quickjs.eval_code(features: [::Quickjs::POLYFILL_INTL])
+
+# Inject the polyfill of Blob and File (W3C File API)
+vm = Quickjs.eval_code(features: [::Quickjs::POLYFILL_FILE])
 ```
 
 </details>
@@ -103,6 +106,9 @@ vm = Quickjs::VM.new(features: [::Quickjs::FEATURE_TIMEOUT])
 
 # Inject the polyfill of Intl
 vm = Quickjs::VM.new(features: [::Quickjs::POLYFILL_INTL])
+
+# Inject the polyfill of Blob and File (W3C File API)
+vm = Quickjs::VM.new(features: [::Quickjs::POLYFILL_FILE])
 ```
 
 #### VM timeout
@@ -163,7 +169,7 @@ vm.logs.last.raw #=> ['log me', nil]
 
 - `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)
+- `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) 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)

data/Rakefile

@@ -11,7 +11,7 @@ end
 
 require 'rake/extensiontask'
 
-task build: :compile
+task build: [:compile, 'polyfills:version:warn']
 
 GEMSPEC = Gem::Specification.load('quickjs.gemspec')
 
@@ -19,4 +19,63 @@ Rake::ExtensionTask.new('quickjsrb', GEMSPEC) do |ext|
   ext.lib_dir = 'lib/quickjs'
 end
 
-task default: %i[clobber compile test]
+def check_polyfill_version!
+  require 'json'
+  require_relative 'lib/quickjs/version'
+
+  package = JSON.parse(File.read(File.expand_path('polyfills/package.json', __dir__)))
+  return if package['version'] == Quickjs::VERSION
+
+  yield package['version'], Quickjs::VERSION
+end
+
+namespace :polyfills do
+  desc 'Build polyfill bundles with rolldown and recompile'
+  task build: :clobber do
+    require 'json'
+    require_relative 'lib/quickjs/version'
+
+    polyfills_dir = File.expand_path('polyfills', __dir__)
+    package_json_path = File.join(polyfills_dir, 'package.json')
+    package = JSON.parse(File.read(package_json_path))
+    old_version = package['version']
+    package['version'] = Quickjs::VERSION
+    File.write(package_json_path, "#{JSON.pretty_generate(package)}\n")
+    if old_version != Quickjs::VERSION
+      warn "\n⚠️  polyfills/package.json version was #{old_version}, updated to #{Quickjs::VERSION}\n\n"
+    end
+
+    Dir.chdir(polyfills_dir) do
+      sh 'npm install' unless File.exist?('node_modules/.package-lock.json') &&
+        File.mtime('node_modules/.package-lock.json') >= File.mtime('package.json')
+      sh 'npx rolldown -c rolldown.config.mjs'
+    end
+
+    Rake::Task[:compile].invoke
+  end
+
+  namespace :version do
+    task :check do
+      check_polyfill_version! do |pkg_v, gem_v|
+        abort "polyfills/package.json version (#{pkg_v}) does not match gem version (#{gem_v}). Run `rake polyfills:build` first."
+      end
+    end
+
+    task :warn do
+      check_polyfill_version! do |pkg_v, gem_v|
+        warn "⚠️  polyfills/package.json version (#{pkg_v}) does not match gem version (#{gem_v}). Run `rake polyfills:build` to sync."
+      end
+    end
+  end
+end
+
+task 'release:guard_clean' => 'polyfills:version:check'
+
+namespace :rbs do
+  desc 'Validate RBS type definitions'
+  task :validate do
+    sh RbConfig.ruby, '-S', 'rbs', '-I', 'sig', 'validate'
+  end
+end
+
+task default: %i[clobber compile test rbs:validate]

data/ext/quickjsrb/extconf.rb

@@ -12,7 +12,10 @@ $srcs = [
   'quickjs.c',
   'quickjs-libc.c',
   'polyfill-intl-en.min.c',
+  'polyfill-file.min.c',
+  'polyfill-encoding.min.c',
   'quickjsrb.c',
+  'quickjsrb_file.c',
 ]
 
 append_cflags('-I$(srcdir)/quickjs')
@@ -61,6 +64,14 @@ polyfill-intl-en.min.js:
 		$(COPY) $(srcdir)/vendor/$@ $@
 polyfill-intl-en.min.c: ./qjsc polyfill-intl-en.min.js
 		./qjsc $(POLYFILL_OPTS) -c -M polyfill/intl-en.so,intlen -m -o $@ polyfill-intl-en.min.js
+polyfill-file.min.js:
+		$(COPY) $(srcdir)/vendor/$@ $@
+polyfill-file.min.c: ./qjsc polyfill-file.min.js
+		./qjsc -fno-string-normalize -fno-eval -fno-proxy -fno-module-loader -c -M polyfill/file.so,file -m -o $@ polyfill-file.min.js
+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
 COMPILE_POLYFILL
   conf
 end

data/ext/quickjsrb/quickjsrb.c

@@ -1,4 +1,27 @@
 #include "quickjsrb.h"
+#include "quickjsrb_file.h"
+
+const char *featureStdId = "feature_std";
+const char *featureOsId = "feature_os";
+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 *undefinedId = "undefined";
+const char *nanId = "NaN";
+
+const char *native_errors[] = {
+    "SyntaxError",
+    "TypeError",
+    "ReferenceError",
+    "RangeError",
+    "EvalError",
+    "URIError",
+    "AggregateError"};
+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 j_error_from_ruby_error(JSContext *ctx, VALUE r_error)
 {
@@ -10,7 +33,7 @@ JSValue j_error_from_ruby_error(JSContext *ctx, VALUE r_error)
 
   // Keep the error alive in VMData to prevent GC before find_ruby_error retrieves it
   VMData *data = JS_GetContextOpaque(ctx);
-  rb_hash_aset(data->alive_errors, r_object_id, r_error);
+  rb_hash_aset(data->alive_objects, r_object_id, r_error);
 
   VALUE r_exception_message = rb_funcall(r_error, rb_intern("message"), 0);
   const char *errorMessage = StringValueCStr(r_exception_message);
@@ -68,6 +91,12 @@ JSValue to_js_value(JSContext *ctx, VALUE r_value)
   }
   default:
   {
+    if (rb_obj_is_kind_of(r_value, rb_cFile))
+    {
+      VMData *data = JS_GetContextOpaque(ctx);
+      if (!JS_IsUndefined(data->j_file_proxy_creator))
+        return quickjsrb_file_to_js(ctx, r_value);
+    }
     if (TYPE(r_value) == T_OBJECT && RTEST(rb_funcall(
                                          r_value,
                                          rb_intern("is_a?"),
@@ -95,8 +124,8 @@ VALUE find_ruby_error(JSContext *ctx, JSValue j_error)
     {
       VMData *data = JS_GetContextOpaque(ctx);
       VALUE r_key = INT2NUM(errorOriginalRubyObjectId);
-      VALUE r_error = rb_hash_aref(data->alive_errors, r_key);
-      rb_hash_delete(data->alive_errors, r_key);
+      VALUE r_error = rb_hash_aref(data->alive_objects, r_key);
+      rb_hash_delete(data->alive_objects, r_key);
       return r_error;
     }
   }
@@ -177,6 +206,36 @@ VALUE to_rb_value(JSContext *ctx, JSValue j_val)
       }
       // will support other errors like just returning an instance of Error
     }
+
+    // Check for Ruby object proxy (e.g., File proxy with rb_object_id on target)
+    {
+      JSValue j_rb_id = JS_GetPropertyStr(ctx, j_val, "rb_object_id");
+      if (JS_VALUE_GET_NORM_TAG(j_rb_id) == JS_TAG_INT || JS_VALUE_GET_NORM_TAG(j_rb_id) == JS_TAG_FLOAT64)
+      {
+        int64_t object_id;
+        JS_ToInt64(ctx, &object_id, j_rb_id);
+        JS_FreeValue(ctx, j_rb_id);
+        if (object_id > 0)
+        {
+          VMData *data = JS_GetContextOpaque(ctx);
+          VALUE r_obj = rb_hash_aref(data->alive_objects, LONG2NUM(object_id));
+          if (!NIL_P(r_obj) && !rb_obj_is_kind_of(r_obj, rb_eException))
+            return r_obj;
+        }
+      }
+      else
+      {
+        JS_FreeValue(ctx, j_rb_id);
+      }
+    }
+
+    // JS File → Quickjs::File
+    {
+      VALUE r_maybe_file = quickjsrb_try_convert_js_file(ctx, j_val);
+      if (!NIL_P(r_maybe_file))
+        return r_maybe_file;
+    }
+
     VALUE r_str = to_r_json(ctx, j_val);
 
     if (rb_funcall(r_str, rb_intern("=="), 1, rb_str_new2("undefined")))
@@ -227,7 +286,7 @@ VALUE to_rb_value(JSContext *ctx, JSValue j_val)
 
       VMData *data = JS_GetContextOpaque(ctx);
       VALUE r_headline = rb_str_new2(headline);
-      rb_ary_push(data->logs, r_log_new("error", rb_ary_new3(1, r_log_body_new(r_headline, r_headline))));
+      dispatch_log(data, "error", rb_ary_new3(1, r_log_body_new(r_headline, r_headline)));
 
       JS_FreeValue(ctx, j_errorClassMessage);
       JS_FreeValue(ctx, j_errorClassName);
@@ -269,7 +328,7 @@ VALUE to_rb_value(JSContext *ctx, JSValue j_val)
 
       VMData *data = JS_GetContextOpaque(ctx);
       VALUE r_headline = rb_str_new2(headline);
-      rb_ary_push(data->logs, r_log_new("error", rb_ary_new3(1, r_log_body_new(r_headline, r_headline))));
+      dispatch_log(data, "error", rb_ary_new3(1, r_log_body_new(r_headline, r_headline)));
 
       free(headline);
 
@@ -418,6 +477,43 @@ static JSValue js_quickjsrb_set_timeout(JSContext *ctx, JSValueConst _this, int
   return JS_UNDEFINED;
 }
 
+static VALUE r_try_call_listener(VALUE r_args)
+{
+  VALUE r_listener = RARRAY_AREF(r_args, 0);
+  VALUE r_log = RARRAY_AREF(r_args, 1);
+  return rb_funcall(r_listener, rb_intern("call"), 1, r_log);
+}
+
+static int dispatch_log(VMData *data, const char *severity, VALUE r_row)
+{
+  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;
+}
+
+static VALUE vm_m_on_log(VALUE r_self)
+{
+  rb_need_block();
+
+  VMData *data;
+  TypedData_Get_Struct(r_self, VMData, &vm_type, data);
+
+  data->log_listener = rb_block_proc();
+
+  return Qnil;
+}
+
 static JSValue js_quickjsrb_log(JSContext *ctx, JSValueConst _this, int argc, JSValueConst *argv, const char *severity)
 {
   VMData *data = JS_GetContextOpaque(ctx);
@@ -467,7 +563,14 @@ static JSValue js_quickjsrb_log(JSContext *ctx, JSValueConst _this, int argc, JS
     rb_ary_push(r_row, r_log_body_new(r_raw, r_c));
   }
 
-  rb_ary_push(data->logs, r_log_new(severity, r_row));
+  int error = dispatch_log(data, severity, r_row);
+  if (error)
+  {
+    VALUE r_error = rb_errinfo();
+    rb_set_errinfo(Qnil);
+    JSValue j_error = j_error_from_ruby_error(ctx, r_error);
+    return JS_Throw(ctx, j_error);
+  }
   return JS_UNDEFINED;
 }
 
@@ -561,6 +664,22 @@ static VALUE vm_m_initialize(int argc, VALUE *argv, VALUE r_self)
     JS_FreeValue(data->context, j_polyfillIntlResult);
   }
 
+  if (RTEST(rb_funcall(r_features, rb_intern("include?"), 1, QUICKJSRB_SYM(featurePolyfillFileId))))
+  {
+    JSValue j_polyfillFileObject = JS_ReadObject(data->context, &qjsc_polyfill_file_min, qjsc_polyfill_file_min_size, JS_READ_OBJ_BYTECODE);
+    JSValue j_polyfillFileResult = JS_EvalFunction(data->context, j_polyfillFileObject);
+    JS_FreeValue(data->context, j_polyfillFileResult);
+
+    quickjsrb_init_file_proxy(data);
+  }
+
+  if (RTEST(rb_funcall(r_features, rb_intern("include?"), 1, QUICKJSRB_SYM(featurePolyfillEncodingId))))
+  {
+    JSValue j_polyfillEncodingObject = JS_ReadObject(data->context, &qjsc_polyfill_encoding_min, qjsc_polyfill_encoding_min_size, JS_READ_OBJ_BYTECODE);
+    JSValue j_polyfillEncodingResult = JS_EvalFunction(data->context, j_polyfillEncodingObject);
+    JS_FreeValue(data->context, j_polyfillEncodingResult);
+  }
+
   JSValue j_console = JS_NewObject(data->context);
   JS_SetPropertyStr(
       data->context, j_console, "log",
@@ -733,6 +852,8 @@ static VALUE vm_m_import(int argc, VALUE *argv, VALUE r_self)
 
 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);
 
@@ -755,5 +876,6 @@ RUBY_FUNC_EXPORTED void Init_quickjsrb(void)
   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

@@ -14,23 +14,23 @@
 
 extern const uint32_t qjsc_polyfill_intl_en_min_size;
 extern const uint8_t qjsc_polyfill_intl_en_min;
+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;
 
-const char *featureStdId = "feature_std";
-const char *featureOsId = "feature_os";
-const char *featureTimeoutId = "feature_timeout";
-const char *featurePolyfillIntlId = "feature_polyfill_intl";
+extern const char *featureStdId;
+extern const char *featureOsId;
+extern const char *featureTimeoutId;
+extern const char *featurePolyfillIntlId;
+extern const char *featurePolyfillFileId;
+extern const char *featurePolyfillEncodingId;
 
-const char *undefinedId = "undefined";
-const char *nanId = "NaN";
+extern const char *undefinedId;
+extern const char *nanId;
 
-const char *native_errors[] = {
-    "SyntaxError",
-    "TypeError",
-    "ReferenceError",
-    "RangeError",
-    "EvalError",
-    "URIError",
-    "AggregateError"};
+extern const char *native_errors[];
+extern const int num_native_errors;
 
 #define QUICKJSRB_SYM(id) \
   (VALUE) { ID2SYM(rb_intern(id)) }
@@ -49,7 +49,9 @@ typedef struct VMData
   VALUE defined_functions;
   struct EvalTime *eval_time;
   VALUE logs;
-  VALUE alive_errors;
+  VALUE log_listener;
+  VALUE alive_objects;
+  JSValue j_file_proxy_creator;
 } VMData;
 
 static void vm_free(void *ptr)
@@ -57,6 +59,9 @@ static void vm_free(void *ptr)
   VMData *data = (VMData *)ptr;
   free(data->eval_time);
 
+  if (!JS_IsUndefined(data->j_file_proxy_creator))
+    JS_FreeValue(data->context, data->j_file_proxy_creator);
+
   JSRuntime *runtime = JS_GetRuntime(data->context);
   JS_SetInterruptHandler(runtime, NULL, NULL);
   js_std_free_handlers(runtime);
@@ -66,7 +71,7 @@ static void vm_free(void *ptr)
   xfree(ptr);
 }
 
-size_t vm_size(const void *data)
+static size_t vm_size(const void *data)
 {
   return sizeof(VMData);
 }
@@ -76,7 +81,8 @@ 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->alive_errors);
+  rb_gc_mark_movable(data->log_listener);
+  rb_gc_mark_movable(data->alive_objects);
 }
 
 static void vm_compact(void *ptr)
@@ -84,7 +90,8 @@ 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->alive_errors = rb_gc_location(data->alive_errors);
+  data->log_listener = rb_gc_location(data->log_listener);
+  data->alive_objects = rb_gc_location(data->alive_objects);
 }
 
 static const rb_data_type_t vm_type = {
@@ -104,7 +111,9 @@ static VALUE vm_alloc(VALUE r_self)
   VALUE obj = TypedData_Make_Struct(r_self, VMData, &vm_type, data);
   data->defined_functions = rb_hash_new();
   data->logs = rb_ary_new();
-  data->alive_errors = rb_hash_new();
+  data->log_listener = Qnil;
+  data->alive_objects = rb_hash_new();
+  data->j_file_proxy_creator = JS_UNDEFINED;
 
   EvalTime *eval_time = malloc(sizeof(EvalTime));
   data->eval_time = eval_time;
@@ -129,17 +138,12 @@ static char *random_string()
 
 static bool is_native_error_name(const char *error_name)
 {
-  bool is_native_error = false;
-  int numStrings = sizeof(native_errors) / sizeof(native_errors[0]);
-  for (int i = 0; i < numStrings; i++)
+  for (int i = 0; i < num_native_errors; i++)
   {
     if (strcmp(native_errors[i], error_name) == 0)
-    {
-      is_native_error = true;
-      break;
-    }
+      return true;
   }
-  return is_native_error;
+  return false;
 }
 
 // Constants
@@ -150,6 +154,8 @@ static void r_define_constants(VALUE r_parent_class)
   rb_define_const(r_parent_class, "MODULE_OS", QUICKJSRB_SYM(featureOsId));
   rb_define_const(r_parent_class, "FEATURE_TIMEOUT", QUICKJSRB_SYM(featureTimeoutId));
   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));
 
   VALUE rb_cQuickjsValue = rb_define_class_under(r_parent_class, "Value", rb_cObject);
   rb_define_const(rb_cQuickjsValue, "UNDEFINED", QUICKJSRB_SYM(undefinedId));
@@ -221,7 +227,7 @@ static VALUE r_log_body_new(VALUE r_raw, VALUE r_c)
 #define QUICKJSRB_ERROR_FOR(name) \
   (VALUE) { rb_const_get(rb_const_get(rb_cClass, rb_intern("Quickjs")), rb_intern(name)) }
 
-VALUE vm_m_initialize_quickjs_error(VALUE self, VALUE r_message, VALUE r_js_name)
+static VALUE vm_m_initialize_quickjs_error(VALUE self, VALUE r_message, VALUE r_js_name)
 {
   rb_call_super(1, &r_message);
   rb_iv_set(self, "@js_name", r_js_name);
@@ -235,9 +241,7 @@ static void r_define_exception_classes(VALUE r_parent_class)
   rb_define_method(r_runtime_error, "initialize", vm_m_initialize_quickjs_error, 2);
   rb_define_attr(r_runtime_error, "js_name", 1, 0);
 
-  // JS native errors
-  int numStrings = sizeof(native_errors) / sizeof(native_errors[0]);
-  for (int i = 0; i < numStrings; i++)
+  for (int i = 0; i < num_native_errors; i++)
   {
     rb_define_class_under(r_parent_class, native_errors[i], r_runtime_error);
   }