rage-iodine 5.6.0 → 6.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ffa46cab7e0fb7fc7550dd142f42b0850287fee60cc0d72b7f52757f52720f7
-  data.tar.gz: c51b8ad9e316c21ed06e6803dcfb5af7bf70fc3eee84a0fd179b2730d2572473
+  metadata.gz: 6096c74f8f76040521a3d8d977be278e9da518a65e3a5dedd7f715ebcf8c8ae7
+  data.tar.gz: 365e0c9732780d5672f3ca2e9b4ca23cfe1a954cb24a2ec58d013e2a59081e1f
 SHA512:
-  metadata.gz: fa99ee4e7abb10b55b6f14aeeaef6bf03e85cf8aff9b33a66f7b4f64097c5ef824e0c3de6663caf00f5404b2d08b663debb60c796a0a44490138a96ac92a832c
-  data.tar.gz: ca2a4ac6f633955b202dccf09661cb7799ae92e16078ef3776c1648e18e2b1ab620f470f4b99b3c75b7d0e8f9b064fad180fd5c9b32ab6ae0ddd60c9d601b58d
+  metadata.gz: 8a8fc73f923a749da72f025797613c4036f79e1405e4f8791b8276a8629cdb511d8f9ec40e1b56087f5bc049058351fd7d126372a179a228de4de77aa3a295b9
+  data.tar.gz: 19526c5ba722bebb05e18cb4125f7cf46acd8c129f5766709888718fe45f6876065fb9fd34f5c98ec8ccfa86a962418b607e63fbf4c249bbc9419ce6cb1ef053

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,14 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ## Changes:
 
+#### Change log v.6.1.0 (2026-10-04)
+
+**Update**: Refactor parameters parsing
+
+#### Change log v.6.0.0 (2026-09-06)
+
+**Update**: Update scheduler `read`/`write` hooks
+
 #### Change log v.5.6.0 (2026-09-06)
 
 **Update**: TCP Socket Listen: Accept Queue

data/CLAUDE.md

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

data/ext/iodine/fio.c

@@ -3687,12 +3687,12 @@ retry_int:
 }
 
 /**
- * This is a complete copy of `fio_read` except that it doesn't attempt to force close the
- * socker on error.
+ * Performs a single read operation using the connection's read hook.
  *
- * The method is currently used by the fiber scheduler.
+ * The return value and errno match the underlying read operation. The socket
+ * isn't closed on error.
  */
-ssize_t fio_read_unsafe(intptr_t uuid, void *buffer, size_t count) {
+ssize_t fio_read_once(intptr_t uuid, void *buffer, size_t count) {
   if (!uuid_is_valid(uuid) || !uuid_data(uuid).open) {
     errno = EBADF;
     return -1;
@@ -3704,22 +3704,36 @@ ssize_t fio_read_unsafe(intptr_t uuid, void *buffer, size_t count) {
       uuid_data(uuid).rw_hooks->read;
   void *udata = uuid_data(uuid).rw_udata;
   fio_unlock(&uuid_data(uuid).sock_lock);
-  int old_errno = errno;
-  ssize_t ret;
-retry_int:
-  ret = rw_read(uuid, udata, buffer, count);
+  ssize_t ret = rw_read(uuid, udata, buffer, count);
   if (ret > 0) {
     fio_touch(uuid);
-    return ret;
   }
-  if (ret < 0 && errno == EINTR)
-    goto retry_int;
-  if (ret < 0 &&
-      (errno == EWOULDBLOCK || errno == EAGAIN || errno == ENOTCONN)) {
-    errno = old_errno;
+  return ret;
+}
+
+/**
+ * Performs a single write operation using the connection's write hook.
+ *
+ * The return value and errno match the underlying write operation. The socket
+ * isn't closed on error and no data is queued for the reactor.
+ */
+ssize_t fio_write_once(intptr_t uuid, const void *buffer, size_t count) {
+  if (!uuid_is_valid(uuid) || !uuid_data(uuid).open) {
+    errno = EBADF;
+    return -1;
+  }
+  if (count == 0)
     return 0;
+  fio_lock(&uuid_data(uuid).sock_lock);
+  ssize_t (*rw_write)(intptr_t, void *, const void *, size_t) =
+      uuid_data(uuid).rw_hooks->write;
+  void *udata = uuid_data(uuid).rw_udata;
+  fio_unlock(&uuid_data(uuid).sock_lock);
+  ssize_t ret = rw_write(uuid, udata, buffer, count);
+  if (ret > 0) {
+    fio_touch(uuid);
   }
-  return -1;
+  return ret;
 }
 
 /**

data/ext/iodine/fio.h

@@ -1198,12 +1198,20 @@ size_t fio_local_addr(char *dest, size_t limit);
 ssize_t fio_read(intptr_t uuid, void *buffer, size_t count);
 
 /**
- * This is a complete copy of `fio_read` except that it doesn't attempt to force close the
- * socker on error.
+ * Performs a single read operation using the connection's read hook.
  *
- * The method is currently used by the fiber scheduler.
+ * The return value and errno match the underlying read operation. The socket
+ * isn't closed on error.
  */
-ssize_t fio_read_unsafe(intptr_t uuid, void *buffer, size_t count);
+ssize_t fio_read_once(intptr_t uuid, void *buffer, size_t count);
+
+/**
+ * Performs a single write operation using the connection's write hook.
+ *
+ * The return value and errno match the underlying write operation. The socket
+ * isn't closed on error and no data is queued for the reactor.
+ */
+ssize_t fio_write_once(intptr_t uuid, const void *buffer, size_t count);
 
 /** The following structure is used for `fio_write2_fn` function arguments. */
 typedef struct {

data/ext/iodine/http.c

@@ -1842,8 +1842,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 +1925,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 == ']') {
@@ -2011,7 +2011,7 @@ static void http_mime_parser_on_data(http_mime_parser_s *parser, void *name,
   // 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);
+    http_add_to_params(http_mime_parser2fio(parser)->params, name, name_len, r_value);
     return;
   }
 
@@ -2024,7 +2024,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 +2073,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;
@@ -2086,7 +2086,7 @@ 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);
+  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;

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_str_new(str, len);
+  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_str_new(NULL, 0);
+    } 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/ext/iodine/scheduler.c

@@ -1,6 +1,8 @@
 #include "iodine.h"
 #include "iodine_store.h"
 #include "ruby.h"
+#include "ruby/fiber/scheduler.h"
+#include "ruby/io/buffer.h"
 
 #include <errno.h>
 #include <stddef.h>
@@ -10,7 +12,7 @@
 
 #include "fio.h"
 
-#define IO_MAX_READ 8192
+#define IO_MAX_READ 65536
 
 static ID call_id;
 static uint8_t ATTACH_ON_READ_READY_CALLBACK;
@@ -151,51 +153,104 @@ static VALUE iodine_scheduler_attach(VALUE self, VALUE r_fd, VALUE r_waittype, V
   (void)self;
 }
 
-static VALUE iodine_scheduler_write(VALUE self, VALUE r_fd, VALUE r_buffer, VALUE r_length, VALUE r_offset) {
+static VALUE iodine_scheduler_write_async(VALUE self, VALUE r_fd, VALUE r_buffer, VALUE r_length, VALUE r_offset) {
   Check_Type(r_fd, T_FIXNUM);
   int fd = FIX2INT(r_fd);
 
-  Check_Type(r_buffer, T_STRING);
-  char *buffer = RSTRING_PTR(r_buffer);
+  const void *buffer;
+  size_t buffer_length;
+  rb_io_buffer_get_bytes_for_reading(r_buffer, &buffer, &buffer_length);
 
   Check_Type(r_length, T_FIXNUM);
-  int length = FIX2INT(r_length);
+  size_t length = NUM2SIZET(r_length);
 
   Check_Type(r_offset, T_FIXNUM);
-  int offset = FIX2INT(r_offset);
+  size_t offset = NUM2SIZET(r_offset);
+
+  if (offset > buffer_length || length > buffer_length - offset) {
+    return rb_fiber_scheduler_io_result(-1, EINVAL);
+  }
+  if (!length) {
+    return r_length;
+  }
 
   void *cpy = fio_malloc(length);
-  memcpy(cpy, buffer, length);
-  fio_write2(fio_fd2uuid(fd), .data.buffer = cpy, .length = length, .offset = offset, .after.dealloc = fio_free);
+  memcpy(cpy, (const char *)buffer + offset, length);
+  fio_write2(fio_fd2uuid(fd), .data.buffer = cpy, .length = length, .after.dealloc = fio_free);
 
   return r_length;
 
   (void)self;
 }
 
-static VALUE iodine_scheduler_read(VALUE self, VALUE r_fd, VALUE r_length, VALUE r_offset) {
+static VALUE iodine_scheduler_write(VALUE self, VALUE r_fd, VALUE r_buffer, VALUE r_length, VALUE r_offset) {
   Check_Type(r_fd, T_FIXNUM);
   int fd = FIX2INT(r_fd);
 
+  const void *buffer;
+  size_t buffer_length;
+  rb_io_buffer_get_bytes_for_reading(r_buffer, &buffer, &buffer_length);
+
   Check_Type(r_length, T_FIXNUM);
-  int length = FIX2INT(r_length);
+  size_t length = NUM2SIZET(r_length);
 
-  if (length == 0) {
-    length = IO_MAX_READ;
+  Check_Type(r_offset, T_FIXNUM);
+  size_t offset = NUM2SIZET(r_offset);
+
+  if (offset > buffer_length || length > buffer_length - offset) {
+    return rb_fiber_scheduler_io_result(-1, EINVAL);
+  }
+  if (!length) {
+    return rb_fiber_scheduler_io_result(0, 0);
   }
 
-  intptr_t uuid = fio_fd2uuid(fd);
-  char buffer[length];
+  ssize_t result = fio_write_once(fio_fd2uuid(fd), (const char *)buffer + offset, length);
+  int error = result < 0 ? errno : 0;
+  return rb_fiber_scheduler_io_result(result, error);
+
+  (void)self;
+}
+
+static VALUE iodine_scheduler_read(VALUE self, VALUE r_fd, VALUE r_buffer, VALUE r_length, VALUE r_offset) {
+  Check_Type(r_fd, T_FIXNUM);
+  int fd = FIX2INT(r_fd);
+
+  void *buffer;
+  size_t buffer_length;
+  rb_io_buffer_get_bytes_for_writing(r_buffer, &buffer, &buffer_length);
+
+  Check_Type(r_length, T_FIXNUM);
+  size_t length = NUM2SIZET(r_length);
+
+  Check_Type(r_offset, T_FIXNUM);
+  size_t offset = NUM2SIZET(r_offset);
+
+  if (offset > buffer_length || length > buffer_length - offset) {
+    return rb_fiber_scheduler_io_result(-1, EINVAL);
+  }
 
-  ssize_t len = fio_read_unsafe(uuid, &buffer, length);
-  if (len == -1) {
-    return Qnil;
+  #if RUBY_FIBER_SCHEDULER_VERSION >= 4
+    if (length > IO_MAX_READ) {
+      length = IO_MAX_READ;
+    }
+  #else
+    if (length == 0) {
+      length = buffer_length - offset;
+      if (length > IO_MAX_READ) {
+        length = IO_MAX_READ;
+      }
+    }
+  #endif
+
+  if (!length) {
+    return rb_fiber_scheduler_io_result(0, 0);
   }
 
-  return rb_str_new(buffer, len);
+  ssize_t result = fio_read_once(fio_fd2uuid(fd), (char *)buffer + offset, length);
+  int error = result < 0 ? errno : 0;
+  return rb_fiber_scheduler_io_result(result, error);
 
   (void)self;
-  (void)r_offset;
 }
 
 static VALUE iodine_scheduler_close(VALUE self) {
@@ -219,8 +274,9 @@ void iodine_scheduler_initialize(void) {
   VALUE SchedulerModule = rb_define_module_under(IodineModule, "Scheduler");
 
   rb_define_module_function(SchedulerModule, "attach", iodine_scheduler_attach, 3);
+  rb_define_module_function(SchedulerModule, "write_async", iodine_scheduler_write_async, 4);
   rb_define_module_function(SchedulerModule, "write", iodine_scheduler_write, 4);
-  rb_define_module_function(SchedulerModule, "read", iodine_scheduler_read, 3);
+  rb_define_module_function(SchedulerModule, "read", iodine_scheduler_read, 4);
   rb_define_module_function(SchedulerModule, "close", iodine_scheduler_close, 0);
 
   VALUE cIO = rb_const_get(rb_cObject, rb_intern2("IO", 2));

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = '5.6.0'.freeze
+  VERSION = '6.1.0'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rage-iodine
 version: !ruby/object:Gem::Version
-  version: 5.6.0
+  version: 6.1.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