rage-iodine 6.0.0 → 6.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1595ec4d4f155fbc845b37ad096018a2a4bfa4f884c0ef96b7112d268fe86e89
-  data.tar.gz: 3185d0901b132a329509238b5188dcd29de1d4145a018adda6b3f9f215e008cf
+  metadata.gz: 67d84c1a37795b81e5bfcdd207e94124b35015905a22908ff4ce99c4e5474ecd
+  data.tar.gz: cc5007e6625fdc36c1c39286e724bfc6cbb9f3711f8b6b3f7e39a84994ddfd63
 SHA512:
-  metadata.gz: 4bbaa335fcd6202ac41a6449a5d8a38302c786b69348b66af733520e83c27bf4529c8a0e90dc7db5f19f8755aadfaf0c71edeb07fea904664b2cbf573da573f0
-  data.tar.gz: 991187eeb695f2128f83859e1025d62d580a1e41fc672822aaf7c8e5130edf15c83721e263a30799311766627fbd132393b50987486d137004f7ae439d11d0b8
+  metadata.gz: 5b3af183fcc0234eb71ae9df561f01ded132b2d2b216cee114309b15f09b9b9814879c92c7c016bbe412cf4587d0cbda449303b9db390d7ed65ce851f64c18cd
+  data.tar.gz: b9341b9d06ce950d505d4bd1c7ecfe9671e93e08cc2d45062c1fdaeca6cbdcd25dfe328d6abe21421bf38548137708b4bb243a91936ce2d735a8f1974376e021

data/.github/workflows/release.yml

@@ -4,6 +4,7 @@ on:
   push:
     branches:
       - master
+      - release/*
     paths:
       - lib/iodine/version.rb
 

data/.gitignore

@@ -18,3 +18,4 @@
 .DS_Store
 spec/examples.txt
 spec/log
+_ref

data/AGENTS.md

@@ -0,0 +1,48 @@
+# Intro
+
+High-performance C web server used as the runtime for [Rage](https://github.com/rage-rb/rage), a fiber-based Ruby framework.
+
+# Main Components
+
+- ext/iodine/fio.[ch] - reactor + base library (spinlocks, atomics, linked lists, strings)
+- ext/iodine/fiobj_str.[ch], fio_ary.[ch], fio_data.[ch] - fio data structures
+- ext/iodine/iodine_caller.[ch] - calling Ruby from C
+- ext/iodine/iodine_http.[ch] - HTTP server, `rack.upgrade` handling
+- ext/iodine/iodine_defer.[ch], iodine_pubsub.[ch] - Iodine Ruby API
+- ext/iodine/scheduler.[ch] - Rage fiber scheduler hooks
+- ext/iodine/iodine_worker_pool.[ch] - Ruby 4.0+ thread pool for `blocking_operation_wait`
+
+## `__http_defer__`
+
+`[:__http_defer__, fiber]` is a private contract between `Rage::FiberWrapper` and `iodine_http.c`:
+
+1. Rage schedules each request in a fiber. If application code yields for non-blocking I/O, the Rack call returns `[:__http_defer__, fiber]`
+2. Iodine pauses the HTTP request, and subscribes to the process-local pub/sub channel
+3. When the fiber finishes, Rage publishes to that channel to resume the request
+
+# rack.upgrade (WebSocket/SSE)
+
+Iodine supports WebSocket/SSE. The upgrade flow:
+
+1. Rage sets `env['rack.upgrade?']` to `:websocket`/`:sse` and `env['rack.upgrade'] = CallbackHandler`
+2. Iodine invokes handler callbacks (`on_open`, `on_message`, `on_close`)
+
+See ext/iodine/iodine_http.c and ext/iodine/iodine_connection.c for implementation.
+
+# Threading
+
+Rage runs Iodine single-threaded; parallelization uses forked processes. New code can exploit this for simplicity, but should remain thread-safe to respect existing Iodine patterns.
+
+# Rules
+
+## 1. Think First
+State assumptions. Surface tradeoffs. If unclear, ask - don't guess.
+
+## 2. Simplicity
+Minimum code for the problem. No speculative features, no premature abstractions, no handling impossible cases. If 200 lines could be 50, rewrite.
+
+## 3. Surgical Changes
+Touch only what's needed. Match existing style. Remove only orphans YOUR changes created. Every changed line should trace to the request.
+
+## 4. Verify
+Define success criteria upfront. Transform vague asks into testable goals ("fix bug" → "write failing test, make it pass").

data/CHANGELOG.md

@@ -6,6 +6,22 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ## Changes:
 
+#### Change log v.5.9.0/v.6.2.0 (2026-10-15)
+
+**Fix**: Prevent process hang on exit caused by a use-after-free in pub/sub teardown (`fio_cluster_at_exit` read a channel freed by `fio_unsubscribe` of its last subscription; it now performs a bounded best-effort cleanup instead). See #21.
+
+#### Change log v.5.8.0 (2026-10-09)
+
+**Update**: Encode parameters as UTF-8
+
+#### Change log v.6.1.0 (2026-10-04)
+
+**Update**: Refactor parameters parsing
+
+#### Change log v.5.7.0 (2026-10-04)
+
+**Update**: Refactor parameters parsing
+
 #### Change log v.6.0.0 (2026-09-06)
 
 **Update**: Update scheduler `read`/`write` hooks

data/CLAUDE.md

@@ -0,0 +1 @@
+AGENTS.md

data/ext/iodine/fio.c

@@ -7658,6 +7658,25 @@ static inline void fio_cluster_inform_root_about_channel(channel_s *ch,
 /* *****************************************************************************
  * Initialization
  **************************************************************************** */
+/* best-effort teardown without fio_unsubscribe: it may free `ch` (and remove
+ * it from the set) while this loop still uses it (#21) */
+FIO_FUNC void fio_pubsub_at_exit_clear(fio_ch_set_s *channels) {
+  while (fio_ch_set_count(channels)) {
+    channel_s *ch = fio_ch_set_last(channels);
+    while (fio_ls_embd_any(&ch->subscriptions)) {
+      subscription_s *sub =
+          FIO_LS_EMBD_OBJ(subscription_s, node, ch->subscriptions.next);
+      fio_ls_embd_remove(&sub->node);
+      sub->unsubscribed = 1;
+      sub->on_message = NULL;
+      sub->on_unsubscribe = NULL;
+      fio_subscription_free(sub);
+    }
+    fio_ch_set_pop(channels);
+  }
+  fio_ch_set_free(channels);
+}
+
 #ifndef __MINGW32__
 static void fio_accept_after_fork(void *ignore) {
   /* prevent `accept` backlog in parent */
@@ -7671,38 +7690,9 @@ static void fio_cluster_at_exit(void *ignore) {
   /* unlock all */
   fio_pubsub_on_fork();
   /* clear subscriptions of all types */
-  while (fio_ch_set_count(&fio_postoffice.patterns.channels)) {
-    channel_s *ch = fio_ch_set_last(&fio_postoffice.patterns.channels);
-    while (fio_ls_embd_any(&ch->subscriptions)) {
-      subscription_s *sub =
-          FIO_LS_EMBD_OBJ(subscription_s, node, ch->subscriptions.next);
-      fio_unsubscribe(sub);
-    }
-    fio_ch_set_pop(&fio_postoffice.patterns.channels);
-  }
-
-  while (fio_ch_set_count(&fio_postoffice.pubsub.channels)) {
-    channel_s *ch = fio_ch_set_last(&fio_postoffice.pubsub.channels);
-    while (fio_ls_embd_any(&ch->subscriptions)) {
-      subscription_s *sub =
-          FIO_LS_EMBD_OBJ(subscription_s, node, ch->subscriptions.next);
-      fio_unsubscribe(sub);
-    }
-    fio_ch_set_pop(&fio_postoffice.pubsub.channels);
-  }
-
-  while (fio_ch_set_count(&fio_postoffice.filters.channels)) {
-    channel_s *ch = fio_ch_set_last(&fio_postoffice.filters.channels);
-    while (fio_ls_embd_any(&ch->subscriptions)) {
-      subscription_s *sub =
-          FIO_LS_EMBD_OBJ(subscription_s, node, ch->subscriptions.next);
-      fio_unsubscribe(sub);
-    }
-    fio_ch_set_pop(&fio_postoffice.filters.channels);
-  }
-  fio_ch_set_free(&fio_postoffice.filters.channels);
-  fio_ch_set_free(&fio_postoffice.patterns.channels);
-  fio_ch_set_free(&fio_postoffice.pubsub.channels);
+  fio_pubsub_at_exit_clear(&fio_postoffice.patterns.channels);
+  fio_pubsub_at_exit_clear(&fio_postoffice.pubsub.channels);
+  fio_pubsub_at_exit_clear(&fio_postoffice.filters.channels);
 
   /* clear engines */
   FIO_PUBSUB_DEFAULT = FIO_PUBSUB_CLUSTER;
@@ -12106,6 +12096,23 @@ FIO_FUNC void fio_pubsub_test(void) {
   ++expect;
   fio_defer_perform();
   FIO_ASSERT(counter == expect, "unsubscribe wasn't called for named channel!");
+
+  /* Regression #21: at-exit cleanup must terminate and empty the set, even
+   * with several subscriptions per channel or an already-marked one. */
+  fio_subscribe(.channel = {0, 9, "hang-test"}, .udata1 = &counter,
+                .on_message = fio_pubsub_test_on_message,
+                .on_unsubscribe = fio_pubsub_test_on_unsubscribe);
+  s = fio_subscribe(.channel = {0, 9, "hang-test"}, .udata1 = &counter,
+                    .on_message = fio_pubsub_test_on_message,
+                    .on_unsubscribe = fio_pubsub_test_on_unsubscribe);
+  FIO_ASSERT(s, "fio_subscribe FAILED for hang-test channel.");
+  fio_trylock(&s->unsubscribed);
+  fio_pubsub_at_exit_clear(&fio_postoffice.pubsub.channels);
+  FIO_ASSERT(!fio_ch_set_count(&fio_postoffice.pubsub.channels),
+             "at-exit cleanup left channels behind (#21)");
+  fio_defer_perform();
+  FIO_ASSERT(counter == expect, "at-exit cleanup shouldn't call callbacks!");
+
   fio_data->is_worker = 0;
   fio_data->active = 0;
   fio_data->workers = 0;

data/ext/iodine/http.c

@@ -68,6 +68,7 @@ static VALUE cUploadedFile;
 static ID create_id;
 static ID path_id;
 static rb_encoding *IodineBinaryEncoding;
+static rb_encoding *IodineUTF8Encoding;
 
 /* *****************************************************************************
 Small Helpers
@@ -1842,8 +1843,8 @@ typedef struct {
 
 #define http_mime_parser2fio(parser) ((http_fio_mime_s *)(parser))
 
-/** Parse a parameter key and add it to the `params` hash. Check `parse_nested_query_internal` for reference. */
-static void add_to_params(VALUE params, char *key, size_t key_len, VALUE value) {
+/** Parse a decoded parameter key and add it to the `params` hash. */
+void http_add_to_params(VALUE params, char *key, size_t key_len, VALUE value) {
   char *pos = NULL;
   if (key_len > 1) {
     pos = memchr(key + 1, '[', key_len - 1);
@@ -1925,7 +1926,7 @@ static void add_to_params(VALUE params, char *key, size_t key_len, VALUE value)
           if (RB_TYPE_P(nested_val, T_HASH)) {
             char *n_pos_start = k_pos + 1, *n_pos_end = k_pos + 1;
 
-            while (nested_val != Qnil && *n_pos_start == '[' && *(n_pos_start + 1) != ']' && *n_pos_end != '&' && *n_pos_end != '=' && n_pos_end < end) {
+            while (nested_val != Qnil && n_pos_end < end && *n_pos_start == '[' && *(n_pos_start + 1) != ']') {
               n_pos_end++;
 
               if (*n_pos_end == ']') {
@@ -2010,8 +2011,8 @@ static void http_mime_parser_on_data(http_mime_parser_s *parser, void *name,
                                      size_t value_len) {
   // for regular values - just add them to params
   if (!filename_len) {
-    VALUE r_value = rb_enc_str_new(value, value_len, IodineBinaryEncoding);
-    add_to_params(http_mime_parser2fio(parser)->params, name, name_len, r_value);
+    VALUE r_value = rb_enc_str_new(value, value_len, IodineUTF8Encoding);
+    http_add_to_params(http_mime_parser2fio(parser)->params, name, name_len, r_value);
     return;
   }
 
@@ -2024,7 +2025,7 @@ static void http_mime_parser_on_data(http_mime_parser_s *parser, void *name,
   close(file);
 
   VALUE r_value = build_file_value(r_tempfile, filename, filename_len, mimetype, mimetype_len);
-  add_to_params(http_mime_parser2fio(parser)->params, name, name_len, r_value);
+  http_add_to_params(http_mime_parser2fio(parser)->params, name, name_len, r_value);
 }
 
 /** Called when the data didn't fit in the buffer. Data will be streamed. */
@@ -2073,7 +2074,7 @@ static void http_mime_parser_on_partial_end(http_mime_parser_s *parser) {
 
   // for a file - add to params and close the fd
   if (fio_parser->partial_fd) {
-    add_to_params(fio_parser->params, RSTRING_PTR(fio_parser->partial_name), RSTRING_LEN(fio_parser->partial_name), fio_parser->partial_tempfile);
+    http_add_to_params(fio_parser->params, RSTRING_PTR(fio_parser->partial_name), RSTRING_LEN(fio_parser->partial_name), fio_parser->partial_tempfile);
     close(fio_parser->partial_fd);
 
     fio_parser->partial_name = Qnil;
@@ -2085,8 +2086,8 @@ static void http_mime_parser_on_partial_end(http_mime_parser_s *parser) {
 
   FIOBJ slice = fiobj_data_slice(fio_parser->h->body, fio_parser->partial_offset, fio_parser->partial_length);
   fio_str_info_s s_slice = fiobj_obj2cstr(slice);
-  VALUE r_value = rb_enc_str_new(s_slice.data, s_slice.len, IodineBinaryEncoding);
-  add_to_params(fio_parser->params, RSTRING_PTR(fio_parser->partial_name), RSTRING_LEN(fio_parser->partial_name), r_value);
+  VALUE r_value = rb_enc_str_new(s_slice.data, s_slice.len, IodineUTF8Encoding);
+  http_add_to_params(fio_parser->params, RSTRING_PTR(fio_parser->partial_name), RSTRING_LEN(fio_parser->partial_name), r_value);
 
   fio_parser->partial_name = Qnil;
   fio_parser->partial_length = 0;
@@ -2701,6 +2702,7 @@ void http_init(void) {
   path_id = rb_intern("path");
 
   IodineBinaryEncoding = rb_enc_find("binary");
+  IodineUTF8Encoding = rb_enc_find("UTF-8");
 }
 
 /* *****************************************************************************

data/ext/iodine/http.h

@@ -781,6 +781,9 @@ HTTP GET and POST parsing helpers
  */
 VALUE http_parse_multipart(http_s *h, char *content_type, size_t content_type_len);
 
+/** Adds a decoded parameter key and Ruby value to a nested parameters hash. */
+void http_add_to_params(VALUE params, char *key, size_t key_len, VALUE value);
+
 /**
  * Parses the query part of an HTTP request/response. Uses `http_add2hash`.
  *

data/ext/iodine/iodine_helpers.c

@@ -210,7 +210,7 @@ static VALUE iodine_rfc2109(VALUE self, VALUE rtm) {
 }
 
 /**
-Convert query string into a Ruby object in (almost always) one pass with no recursion.
+Convert query string into a Ruby object without recursion.
 
 
         Iodine::Rack::Utils.parse_nested_query("a=1&b[]=2&c[d]=3") # => { "a" => "1", "b" => ["2"], "c" => { "d" => "3" } }
@@ -240,182 +240,68 @@ Convert query string into a Ruby object in (almost always) one pass with no recu
                         Rack:    64257.9 i/s - 16.94x  slower
 
 */
+static VALUE build_query_component(char *str, size_t len,
+                                    uint8_t should_decode) {
+  VALUE result = rb_enc_str_new(str, len, IodineUTF8Encoding);
+  if (should_decode) {
+    url_decode_inplace(Qnil, result);
+  }
+  return result;
+}
+
 static VALUE parse_nested_query_internal(char *str, size_t len) {
-  uint8_t should_decode = 0;
   VALUE params = rb_hash_new();
-
-  char *pos = str, *k_pos = str, *v_pos = str;
-  const char *end = str + len;
+  char *pos = str;
+  char *end = str + len;
 
   while (pos < end) {
-    k_pos++;
-
-    if (*k_pos == '=') { // plain param
-      v_pos = k_pos + 1;
-      while (*v_pos != '&' && v_pos < end) {
-        if (*v_pos == '%' || *v_pos == '+') {
-          should_decode = 1;
-        }
-        v_pos++;
-      }
-
-      VALUE k = ID2SYM(rb_intern2(pos, k_pos - pos)), v = rb_str_new(k_pos + 1, v_pos - k_pos - 1);
-      if (should_decode) {
-        rb_hash_aset(params, k, url_decode_inplace(Qnil, v));
-        should_decode = 0;
-      } else {
-        rb_hash_aset(params, k, v);
-      }
-      pos = k_pos = v_pos + 1;
-
-    } else if (*k_pos == '[') { // things are about to get rough now
-      VALUE arr = Qnil, hsh = Qnil, hsh_key = Qnil;
-      VALUE k = ID2SYM(rb_intern2(pos, k_pos - pos)), v;
-      pos = k_pos;
-      uint8_t depth = 0;
-
-      while (*pos != '=' && pos < end) {
-        if (depth++ == PARAMS_MAX_DEPTH) {
-          rb_raise(rb_eRuntimeError, "Params too deep");
-        }
-
-        if (*pos == '[' && *(pos + 1) == ']') { // array
-          if (arr != Qnil) {
-            VALUE tmp = rb_ary_new();
-            rb_ary_push(arr, tmp);
-            arr = tmp;
-          } else if (hsh != Qnil) {
-            arr = rb_hash_aref(hsh, hsh_key);
-            if (arr == Qnil) {
-              arr = rb_ary_new();
-              rb_hash_aset(hsh, hsh_key, arr);
-            } else {
-              Check_Type(arr, T_ARRAY);
-            }
-            hsh = hsh_key = Qnil;
-          } else {
-            VALUE tmp = rb_hash_aref(params, k);
-            if (tmp != Qnil) {
-              Check_Type(tmp, T_ARRAY);
-              arr = tmp;
-            } else {
-              arr = rb_ary_new();
-              rb_hash_aset(params, k, arr);
-            }
-          }
-
-          pos += 2;
-
-        } else if (*pos == '[' && *(pos + 1) != ']') { // hash
-          if (pos + 2 < end) {
-            k_pos = memchr(pos + 2, ']', end - pos - 2);
-          } else {
-            k_pos = NULL;
-          }
-
-          if (!k_pos) {
-            rb_raise(rb_eRuntimeError, "Bad params");
-          }
-
-          VALUE prev_hsh_key = hsh_key;
-          hsh_key = ID2SYM(rb_intern2(pos + 1, k_pos - pos - 1));
-
-          if (hsh != Qnil) {
-            VALUE existing = rb_hash_aref(hsh, prev_hsh_key);
-            if (existing != Qnil) {
-              Check_Type(existing, T_HASH);
-              hsh = existing;
-            } else {
-              VALUE tmp = rb_hash_new();
-              rb_hash_aset(hsh, prev_hsh_key, tmp);
-              hsh = tmp;
-            }
-          } else if (arr != Qnil) {
-            VALUE nested_val = Qnil;
-            if (RARRAY_LEN(arr) != 0) {
-              VALUE tmp = rb_ary_entry(arr, -1);
-              Check_Type(tmp, T_HASH);
-              nested_val = rb_hash_aref(tmp, hsh_key);
-            }
-
-            // handle Rails' smart key grouping;
-            //   "users[][data][id]=11&users[][data][name]=ross&users[][data][id]=22&users[][data][name]=chandler"
-            // should result in:
-            //   { users: [{ data: { id: "11", name: "ross" } }, { data: { id: "22", name: "chandler" } }] }
-            if (RB_TYPE_P(nested_val, T_HASH)) {
-              char *n_pos_start = k_pos + 1, *n_pos_end = k_pos + 1;
-
-              while (nested_val != Qnil && *n_pos_start == '[' && *(n_pos_start + 1) != ']' && *n_pos_end != '&' && *n_pos_end != '=' && n_pos_end < end) {
-                n_pos_end++;
-
-                if (*n_pos_end == ']') {
-                  VALUE nested_key = ID2SYM(rb_intern2(n_pos_start + 1, n_pos_end - n_pos_start - 1));
-                  Check_Type(nested_val, T_HASH);
-                  nested_val = rb_hash_aref(nested_val, nested_key);
-                  n_pos_start = ++n_pos_end;
-                }
-              }
-            }
-
-            // use a new hash if there's none under this key or the existing one already has such key
-            if (RARRAY_LEN(arr) == 0 || nested_val != Qnil) {
-              hsh = rb_hash_new();
-              rb_ary_push(arr, hsh);
-            } else {
-              hsh = rb_ary_entry(arr, -1);
-              if (hsh != Qnil) {
-                Check_Type(hsh, T_HASH);
-              }
-            }
-
-            arr = Qnil;
-          } else {
-            VALUE tmp = rb_hash_aref(params, k);
-            if (tmp != Qnil) {
-              Check_Type(tmp, T_HASH);
-              hsh = tmp;
-            } else {
-              hsh = rb_hash_new();
-              rb_hash_aset(params, k, hsh);
-            }
-          }
-
-          pos = k_pos + 1;
-
+    char *pair_end = pos;
+    char *separator = NULL;
+    uint8_t key_should_decode = 0;
+    uint8_t value_should_decode = 0;
+
+    while (pair_end < end && *pair_end != '&') {
+      if (!separator && *pair_end == '=') {
+        separator = pair_end;
+      } else if (*pair_end == '%' || *pair_end == '+') {
+        if (separator) {
+          value_should_decode = 1;
         } else {
-          pos++;
+          key_should_decode = 1;
         }
       }
+      pair_end++;
+    }
 
-      //
-      // write the final object into `params`
-      //
-
-      for (v_pos = pos + 1; *v_pos != '&' && v_pos < end; v_pos++) {
-        if (*v_pos == '%' || *v_pos == '+') {
-          should_decode = 1;
-        }
-      }
+    char *key_end = separator ? separator : pair_end;
+    VALUE key = Qnil;
+    char *key_data = pos;
+    size_t key_len = key_end - pos;
 
-      v = rb_str_new(pos + 1, v_pos - pos - 1);
-      if (should_decode) {
-        url_decode_inplace(Qnil, v);
-        should_decode = 0;
-      }
+    if (key_should_decode) {
+      key = build_query_component(pos, key_len, 1);
+      key_data = RSTRING_PTR(key);
+      key_len = RSTRING_LEN(key);
+    }
 
-      if (arr != Qnil) {
-        rb_ary_push(arr, v);
-      } else {
-        rb_hash_aset(hsh, hsh_key, v);
-      }
+    VALUE value;
+    if (separator) {
+      value = build_query_component(separator + 1,
+                                     pair_end - separator - 1,
+                                     value_should_decode);
+    } else if (key_len > 1 && memchr(key_data + 1, '[', key_len - 1)) {
+      value = rb_enc_str_new(NULL, 0, IodineUTF8Encoding);
+    } else {
+      value = Qnil;
+    }
 
-      pos = k_pos = v_pos + 1;
+    http_add_to_params(params, key_data, key_len, value);
+    RB_GC_GUARD(key);
 
-    } else if (*k_pos == '&' || k_pos >= end) {
-      VALUE k = ID2SYM(rb_intern2(pos, k_pos - pos));
-      rb_hash_aset(params, k, Qnil);
-      pos = k_pos + 1;
+    if (pair_end == end) {
+      break;
     }
+    pos = pair_end + 1;
   }
 
   return params;
@@ -425,21 +311,26 @@ static VALUE parse_nested_query_internal(char *str, size_t len) {
 Convert query string into a Ruby object.
 */
 static VALUE parse_nested_query(VALUE self, VALUE r_str) {
-  return parse_nested_query_internal(RSTRING_PTR(r_str), RSTRING_LEN(r_str));
   (void)self;
+  Check_Type(r_str, T_STRING);
+  VALUE result =
+      parse_nested_query_internal(RSTRING_PTR(r_str), RSTRING_LEN(r_str));
+  RB_GC_GUARD(r_str);
+  return result;
 }
 
 /**
 Convert urlencoded body into a Ruby object.
 */
 static VALUE parse_urlencoded_nested_query(VALUE self, VALUE r_str) {
-  ssize_t len = http_decode_url(RSTRING_PTR(r_str), RSTRING_PTR(r_str), RSTRING_LEN(r_str));
-  if (len < 0) {
-    rb_raise(rb_eRuntimeError, "Invalid encoding");
-  }
-  
-  return parse_nested_query_internal(RSTRING_PTR(r_str), len);
   (void)self;
+  Check_Type(r_str, T_STRING);
+  char *str = RSTRING_PTR(r_str);
+  size_t len = RSTRING_LEN(r_str);
+
+  VALUE result = parse_nested_query_internal(str, len);
+  RB_GC_GUARD(r_str);
+  return result;
 }
 
 /**

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = '6.0.0'.freeze
+  VERSION = '6.2.0'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rage-iodine
 version: !ruby/object:Gem::Version
-  version: 6.0.0
+  version: 6.2.0
 platform: ruby
 authors:
 - Boaz Segev
@@ -125,7 +125,9 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".yardopts"
+- AGENTS.md
 - CHANGELOG.md
+- CLAUDE.md
 - Gemfile
 - LICENSE.txt
 - LIMITS.md