quicsilver 0.2.0 → 0.4.0

data/ext/quicsilver/quicsilver.c

@@ -1,26 +1,45 @@
 #include <ruby.h>
+#include <ruby/thread.h>
+#define QUIC_API_ENABLE_PREVIEW_FEATURES 1
 #include "msquic.h"
-#include <pthread.h>
 #include <stdlib.h>
 #include <string.h>
+#include <unistd.h>
+
+#if __linux__
+#include <sys/epoll.h>
+#elif __APPLE__ || __FreeBSD__
+#include <sys/event.h>
+#endif
 
 static VALUE mQuicsilver;
 
-// Event queue for callbacks
-typedef struct CallbackEvent {
-    HQUIC connection;
-    void* connection_ctx;  // ConnectionContext pointer for building connection_data
-    VALUE client_obj;      // Ruby client object (for routing callbacks)
-    char* event_type;
-    uint64_t stream_id;
-    char* data;
-    size_t data_len;
-    struct CallbackEvent* next;
-} CallbackEvent;
+// Custom execution: app owns the event loop, MsQuic spawns no threads
+static QUIC_EVENTQ EventQ = -1;        // kqueue (macOS) / epoll (Linux)
+static QUIC_EXECUTION* ExecContext = NULL;
+
+#if __linux__
+#include <sys/eventfd.h>
+static int WakeFd = -1;  // eventfd for waking epoll
+#endif
+#define WAKE_IDENT 0xCAFE  // kqueue EVFILT_USER identifier (macOS only)
 
-static CallbackEvent* event_queue_head = NULL;
-static CallbackEvent* event_queue_tail = NULL;
-static pthread_mutex_t queue_mutex = PTHREAD_MUTEX_INITIALIZER;
+// Wake the event loop from another thread (e.g. after StreamSend)
+static void
+wake_event_loop(void)
+{
+    if (EventQ == -1) return;
+#if __linux__
+    if (WakeFd != -1) {
+        uint64_t val = 1;
+        write(WakeFd, &val, sizeof(val));
+    }
+#elif __APPLE__ || __FreeBSD__
+    struct kevent kev;
+    EV_SET(&kev, WAKE_IDENT, EVFILT_USER, 0, NOTE_TRIGGER, 0, NULL);
+    kevent(EventQ, &kev, 1, NULL, 0, NULL);
+#endif
+}
 
 // Global MSQUIC API table
 static const QUIC_API_TABLE* MsQuic = NULL;
@@ -56,119 +75,199 @@ typedef struct {
     VALUE client_obj;      // Ruby client object (copied from connection context)
     int started;
     int shutdown;
+    int early_data;        // Set when stream received 0-RTT data
     QUIC_STATUS error_status;
 } StreamContext;
 
-// Enqueue a callback event (thread-safe)
-// NOTE: Called from QUIC callback threads without GVL - cannot use Ruby API here
-static void
-enqueue_callback_event(HQUIC connection, void* connection_ctx, VALUE client_obj, const char* event_type, uint64_t stream_id, const char* data, size_t data_len)
-{
-    CallbackEvent* event = (CallbackEvent*)malloc(sizeof(CallbackEvent));
-    if (event == NULL) return;
-
-    event->connection = connection;
-    event->connection_ctx = connection_ctx;
-    event->client_obj = client_obj;  // Store raw VALUE - will validate before use
-    event->event_type = strdup(event_type);
-    event->stream_id = stream_id;
-    event->data = (char*)malloc(data_len);
-    if (event->data != NULL) {
-        memcpy(event->data, data, data_len);
-    }
-    event->data_len = data_len;
-    event->next = NULL;
-
-    pthread_mutex_lock(&queue_mutex);
-    if (event_queue_tail == NULL) {
-        event_queue_head = event_queue_tail = event;
+// Pending stream priorities — set from Ruby threads, applied on MsQuic event thread.
+// Simple array-based storage (max 256 pending). Key = stream handle, value = priority + 1.
+#define MAX_PENDING_PRIORITIES 256
+static struct { HQUIC stream; uint16_t priority_plus_one; } PendingPriorities[MAX_PENDING_PRIORITIES];
+static int PendingPriorityCount = 0;
+
+// rb_protect wrapper — catches Ruby exceptions so they don't longjmp
+// through MsQuic callback frames (which would corrupt MsQuic state).
+// All Ruby object construction AND the funcall happen inside rb_protect.
+struct dispatch_ruby_args {
+    HQUIC connection;
+    void* connection_ctx;
+    VALUE client_obj;
+    const char* event_type;
+    uint64_t stream_id;
+    const char* data;
+    size_t data_len;
+    int early_data;
+};
+
+static VALUE
+dispatch_ruby_body(VALUE arg)
+{
+    struct dispatch_ruby_args* a = (struct dispatch_ruby_args*)arg;
+
+    if (NIL_P(a->client_obj)) {
+        VALUE server_class = rb_const_get_at(mQuicsilver, rb_intern("Server"));
+        if (rb_class_real(CLASS_OF(server_class)) == rb_cClass) {
+            VALUE connection_data = rb_ary_new2(2);
+            rb_ary_push(connection_data, ULL2NUM((uintptr_t)a->connection));
+            rb_ary_push(connection_data, ULL2NUM((uintptr_t)a->connection_ctx));
+            VALUE argv[5] = {
+                connection_data,
+                ULL2NUM(a->stream_id),
+                rb_str_new_cstr(a->event_type),
+                rb_str_new(a->data, a->data_len),
+                a->early_data ? Qtrue : Qfalse
+            };
+            rb_funcallv(server_class, rb_intern("handle_stream"), 5, argv);
+        }
     } else {
-        event_queue_tail->next = event;
-        event_queue_tail = event;
+        if (RB_TYPE_P(a->client_obj, T_OBJECT)) {
+            VALUE argv[4] = {
+                ULL2NUM(a->stream_id),
+                rb_str_new_cstr(a->event_type),
+                rb_str_new(a->data, a->data_len),
+                a->early_data ? Qtrue : Qfalse
+            };
+            rb_funcallv(a->client_obj, rb_intern("handle_stream_event"), 4, argv);
+        }
     }
-    pthread_mutex_unlock(&queue_mutex);
+
+    return Qnil;
 }
 
-// Free a single event
+// Dispatch event to Ruby — entire body wrapped in rb_protect so no Ruby call
+// (object construction or funcall) can longjmp through MsQuic callback frames.
 static void
-free_event(CallbackEvent* event)
+dispatch_to_ruby(HQUIC connection, void* connection_ctx, VALUE client_obj,
+                 const char* event_type, uint64_t stream_id,
+                 const char* data, size_t data_len, int early_data)
 {
-    if (event == NULL) return;
-    free(event->event_type);
-    free(event->data);
-    free(event);
+    struct dispatch_ruby_args args;
+    args.connection = connection;
+    args.connection_ctx = connection_ctx;
+    args.client_obj = client_obj;
+    args.event_type = event_type;
+    args.stream_id = stream_id;
+    args.data = data;
+    args.data_len = data_len;
+    args.early_data = early_data;
+
+    int state = 0;
+    rb_protect(dispatch_ruby_body, (VALUE)&args, &state);
+    if (state) {
+        rb_set_errinfo(Qnil);
+        fprintf(stderr, "Quicsilver: exception in callback\n");
+    }
 }
 
-// Process all pending callback events (called from Ruby)
-static VALUE
-quicsilver_process_events(VALUE self)
+// Platform I/O wait — called without GVL so other Ruby threads can run
+struct poll_args {
+    QUIC_EVENTQ eq;
+    QUIC_CQE events[64];
+    int max_events;
+    int timeout_ms;
+    int count;
+};
+
+static void*
+eventq_wait_nogvl(void* arg)
 {
-    CallbackEvent* event;
-    VALUE server_class = Qnil;
-    int processed = 0;
-
-    // Get Server class for server events (client_obj == Qnil)
-    server_class = rb_const_get_at(mQuicsilver, rb_intern("Server"));
-    if (rb_class_real(CLASS_OF(server_class)) != rb_cClass) {
-        server_class = Qnil;
-    }
+    struct poll_args* a = (struct poll_args*)arg;
+#if __linux__
+    a->count = epoll_wait(a->eq, a->events, a->max_events, a->timeout_ms);
+#elif __APPLE__ || __FreeBSD__
+    struct timespec ts;
+    ts.tv_sec = a->timeout_ms / 1000;
+    ts.tv_nsec = (a->timeout_ms % 1000) * 1000000;
+    a->count = kevent(a->eq, NULL, 0, a->events, a->max_events, &ts);
+#endif
+    return NULL;
+}
 
-    // Process events in a loop, but limit iterations to avoid GVL starvation
-    int max_iterations = 100;
-    int iteration = 0;
+static inline QUIC_SQE*
+cqe_get_sqe(QUIC_CQE* cqe)
+{
+#if __linux__
+    return (QUIC_SQE*)cqe->data.ptr;
+#elif __APPLE__ || __FreeBSD__
+    return (QUIC_SQE*)cqe->udata;
+#endif
+}
 
-    while (iteration++ < max_iterations) {
-        pthread_mutex_lock(&queue_mutex);
-        event = event_queue_head;
-        if (event != NULL) {
-            event_queue_head = event->next;
-            if (event_queue_head == NULL) {
-                event_queue_tail = NULL;
-            }
+// Drive MsQuic execution: poll internal timers, wait for I/O, fire completions.
+// Callbacks (StreamCallback, ConnectionCallback) fire HERE on the Ruby thread.
+static VALUE
+quicsilver_poll(VALUE self)
+{
+    if (ExecContext == NULL) return INT2NUM(0);
+
+    // 1. ExecutionPoll — process MsQuic timers/state, may fire callbacks (has GVL)
+    uint32_t wait_ms = MsQuic->ExecutionPoll(ExecContext);
+
+    // 2. Wait for I/O completions (releases GVL)
+    struct poll_args args;
+    args.eq = EventQ;
+    args.max_events = 64;
+    // With wake_event_loop(), Ruby threads instantly unblock us when work is
+    // queued. Cap at 1s as a safety net for shutdown responsiveness.
+    uint32_t actual_wait = (wait_ms == UINT32_MAX) ? 1000 : wait_ms;
+    args.timeout_ms = (int)actual_wait;
+    args.count = 0;
+
+    rb_thread_call_without_gvl(eventq_wait_nogvl, &args, RUBY_UBF_IO, NULL);
+
+    // 3. Fire completions — MsQuic callbacks run here (has GVL)
+    for (int i = 0; i < args.count; i++) {
+#if __linux__
+        if (args.events[i].data.ptr == NULL) {
+            uint64_t val;
+            read(WakeFd, &val, sizeof(val));  // drain eventfd
+            continue;
         }
-        pthread_mutex_unlock(&queue_mutex);
-
-        if (event == NULL) break;
-
-        // Route based on client_obj:
-        // - If Qnil: server event, route to Server.handle_stream with connection_data
-        // - If not Qnil: client event, route to client_obj.handle_stream_event
-        int handled = 0;
-
-        if (NIL_P(event->client_obj)) {
-            // Server event - build connection_data array [connection_handle, context_ptr]
-            if (!NIL_P(server_class)) {
-                VALUE connection_data = rb_ary_new2(2);
-                rb_ary_push(connection_data, ULL2NUM((uintptr_t)event->connection));
-                rb_ary_push(connection_data, ULL2NUM((uintptr_t)event->connection_ctx));
-
-                rb_funcall(server_class, rb_intern("handle_stream"), 4,
-                    connection_data,
-                    ULL2NUM(event->stream_id),
-                    rb_str_new_cstr(event->event_type),
-                    rb_str_new(event->data, event->data_len));
-                handled = 1;
-            }
-        } else {
-            // Client event - validate object is a real Ruby object before calling
-            // This catches use-after-free when connection was closed but events still queued
-            if (RB_TYPE_P(event->client_obj, T_OBJECT)) {
-                rb_funcall(event->client_obj, rb_intern("handle_stream_event"), 3,
-                    ULL2NUM(event->stream_id),
-                    rb_str_new_cstr(event->event_type),
-                    rb_str_new(event->data, event->data_len));
-                handled = 1;
-            }
+#elif __APPLE__ || __FreeBSD__
+        if (args.events[i].filter == EVFILT_USER && args.events[i].ident == WAKE_IDENT) continue;
+#endif
+        QUIC_SQE* sqe = cqe_get_sqe(&args.events[i]);
+        if (sqe && sqe->Completion) {
+            sqe->Completion(&args.events[i]);
         }
+    }
 
-        if (handled) {
-            processed++;
-        }
+    return INT2NUM(args.count);
+}
 
-        free_event(event);
+// Inline poll for use during synchronous waits (e.g. wait_for_connection).
+// Short non-blocking poll — keeps MsQuic alive while we spin.
+static void
+poll_inline(int timeout_ms)
+{
+    if (ExecContext == NULL) return;
+
+    MsQuic->ExecutionPoll(ExecContext);
+
+    QUIC_CQE events[8];
+#if __linux__
+    int count = epoll_wait(EventQ, events, 8, timeout_ms);
+#elif __APPLE__ || __FreeBSD__
+    struct timespec ts;
+    ts.tv_sec = timeout_ms / 1000;
+    ts.tv_nsec = (timeout_ms % 1000) * 1000000;
+    int count = kevent(EventQ, NULL, 0, events, 8, &ts);
+#endif
+    for (int i = 0; i < count; i++) {
+#if __linux__
+        if (events[i].data.ptr == NULL) {
+            uint64_t val;
+            read(WakeFd, &val, sizeof(val));  // drain eventfd
+            continue;
+        }
+#elif __APPLE__ || __FreeBSD__
+        if (events[i].filter == EVFILT_USER && events[i].ident == WAKE_IDENT) continue;
+#endif
+        QUIC_SQE* sqe = cqe_get_sqe(&events[i]);
+        if (sqe && sqe->Completion) {
+            sqe->Completion(&events[i]);
+        }
     }
-
-    return INT2NUM(processed);
 }
 
 QUIC_STATUS
@@ -180,34 +279,81 @@ StreamCallback(HQUIC Stream, void* Context, QUIC_STREAM_EVENT* Event)
         return QUIC_STATUS_SUCCESS;
     }
 
+    // Apply pending priority on the event loop thread (safe context for SetParam)
+    for (int i = 0; i < PendingPriorityCount; i++) {
+        if (PendingPriorities[i].stream == Stream) {
+            uint16_t priority = PendingPriorities[i].priority_plus_one - 1;
+            // Remove by swapping with last
+            PendingPriorities[i] = PendingPriorities[--PendingPriorityCount];
+            MsQuic->SetParam(Stream, QUIC_PARAM_STREAM_PRIORITY, sizeof(priority), &priority);
+            break;
+        }
+    }
+
     switch (Event->Type) {
-        case QUIC_STREAM_EVENT_RECEIVE:
-            // Client sent data - enqueue for Ruby processing
+        case QUIC_STREAM_EVENT_RECEIVE: {
+            int has_fin = (Event->RECEIVE.Flags & QUIC_RECEIVE_FLAG_FIN) != 0;
+
+            // Track 0-RTT early data for replay protection
+            if (Event->RECEIVE.Flags & QUIC_RECEIVE_FLAG_0_RTT) {
+                ctx->early_data = 1;
+            }
+
+            if (Event->RECEIVE.BufferCount == 0 && has_fin) {
+                // Empty FIN — headers-only request/response with no body
+                uint64_t stream_id = 0;
+                uint32_t stream_id_len = sizeof(stream_id);
+                MsQuic->GetParam(Stream, QUIC_PARAM_STREAM_ID, &stream_id_len, &stream_id);
+
+                dispatch_to_ruby(ctx->connection, ctx->connection_ctx, ctx->client_obj,
+                    "RECEIVE_FIN", stream_id, (const char*)&Stream, sizeof(HQUIC), ctx->early_data);
+                break;
+            }
+
             if (Event->RECEIVE.BufferCount > 0) {
-                const QUIC_BUFFER* buffer = &Event->RECEIVE.Buffers[0];
-                const char* event_type = (Event->RECEIVE.Flags & QUIC_RECEIVE_FLAG_FIN) ? "RECEIVE_FIN" : "RECEIVE";
+                const char* event_type = has_fin ? "RECEIVE_FIN" : "RECEIVE";
 
-                // Get the QUIC protocol stream ID (0, 4, 8, 12...)
                 uint64_t stream_id = 0;
                 uint32_t stream_id_len = sizeof(stream_id);
                 MsQuic->GetParam(Stream, QUIC_PARAM_STREAM_ID, &stream_id_len, &stream_id);
 
-                // Pack stream handle pointer along with data for RECEIVE_FIN
+                size_t total_data_len = 0;
+                for (uint32_t b = 0; b < Event->RECEIVE.BufferCount; b++) {
+                    total_data_len += Event->RECEIVE.Buffers[b].Length;
+                }
+
                 if (Event->RECEIVE.Flags & QUIC_RECEIVE_FLAG_FIN) {
-                    // Create combined buffer: [stream_handle(8 bytes)][data]
-                    size_t total_len = sizeof(HQUIC) + buffer->Length;
+                    // Create combined buffer: [stream_handle(8)][all data]
+                    size_t total_len = sizeof(HQUIC) + total_data_len;
                     char* combined = (char*)malloc(total_len);
                     if (combined != NULL) {
                         memcpy(combined, &Stream, sizeof(HQUIC));
-                        memcpy(combined + sizeof(HQUIC), buffer->Buffer, buffer->Length);
-                        enqueue_callback_event(ctx->connection, ctx->connection_ctx, ctx->client_obj, event_type, stream_id, combined, total_len);
+                        size_t offset = sizeof(HQUIC);
+                        for (uint32_t b = 0; b < Event->RECEIVE.BufferCount; b++) {
+                            memcpy(combined + offset, Event->RECEIVE.Buffers[b].Buffer, Event->RECEIVE.Buffers[b].Length);
+                            offset += Event->RECEIVE.Buffers[b].Length;
+                        }
+                        dispatch_to_ruby(ctx->connection, ctx->connection_ctx, ctx->client_obj, event_type, stream_id, combined, total_len, ctx->early_data);
                         free(combined);
                     }
+                } else if (Event->RECEIVE.BufferCount == 1) {
+                    dispatch_to_ruby(ctx->connection, ctx->connection_ctx, ctx->client_obj, event_type, stream_id,
+                        (const char*)Event->RECEIVE.Buffers[0].Buffer, Event->RECEIVE.Buffers[0].Length, 0);
                 } else {
-                    enqueue_callback_event(ctx->connection, ctx->connection_ctx, ctx->client_obj, event_type, stream_id, (const char*)buffer->Buffer, buffer->Length);
+                    char* combined = (char*)malloc(total_data_len);
+                    if (combined != NULL) {
+                        size_t offset = 0;
+                        for (uint32_t b = 0; b < Event->RECEIVE.BufferCount; b++) {
+                            memcpy(combined + offset, Event->RECEIVE.Buffers[b].Buffer, Event->RECEIVE.Buffers[b].Length);
+                            offset += Event->RECEIVE.Buffers[b].Length;
+                        }
+                        dispatch_to_ruby(ctx->connection, ctx->connection_ctx, ctx->client_obj, event_type, stream_id, combined, total_data_len, 0);
+                        free(combined);
+                    }
                 }
             }
             break;
+        }
         case QUIC_STREAM_EVENT_SEND_COMPLETE:
             // Free the send buffer that was allocated in quicsilver_send_stream
             if (Event->SEND_COMPLETE.ClientContext != NULL) {
@@ -216,11 +362,38 @@ StreamCallback(HQUIC Stream, void* Context, QUIC_STREAM_EVENT* Event)
             break;
         case QUIC_STREAM_EVENT_SHUTDOWN_COMPLETE:
             ctx->shutdown = 1;
+            free(ctx);
+            MsQuic->SetCallbackHandler(Stream, (void*)StreamCallback, NULL);
+            if (Event->SHUTDOWN_COMPLETE.AppCloseInProgress == FALSE) {
+                MsQuic->StreamClose(Stream);
+            }
             break;
         case QUIC_STREAM_EVENT_PEER_SEND_SHUTDOWN:
             break;
-        case QUIC_STREAM_EVENT_PEER_SEND_ABORTED:
+        case QUIC_STREAM_EVENT_PEER_SEND_ABORTED: {
+            // Peer sent RESET_STREAM — pack [stream_handle(8)][error_code(8)]
+            uint64_t stream_id = 0;
+            uint32_t stream_id_len = sizeof(stream_id);
+            MsQuic->GetParam(Stream, QUIC_PARAM_STREAM_ID, &stream_id_len, &stream_id);
+            uint64_t error_code = Event->PEER_SEND_ABORTED.ErrorCode;
+            char combined[sizeof(HQUIC) + sizeof(uint64_t)];
+            memcpy(combined, &Stream, sizeof(HQUIC));
+            memcpy(combined + sizeof(HQUIC), &error_code, sizeof(uint64_t));
+            dispatch_to_ruby(ctx->connection, ctx->connection_ctx, ctx->client_obj, "STREAM_RESET", stream_id, combined, sizeof(combined), 0);
+            break;
+        }
+        case QUIC_STREAM_EVENT_PEER_RECEIVE_ABORTED: {
+            // Peer sent STOP_SENDING — pack [stream_handle(8)][error_code(8)]
+            uint64_t stream_id = 0;
+            uint32_t stream_id_len = sizeof(stream_id);
+            MsQuic->GetParam(Stream, QUIC_PARAM_STREAM_ID, &stream_id_len, &stream_id);
+            uint64_t error_code = Event->PEER_RECEIVE_ABORTED.ErrorCode;
+            char combined[sizeof(HQUIC) + sizeof(uint64_t)];
+            memcpy(combined, &Stream, sizeof(HQUIC));
+            memcpy(combined + sizeof(HQUIC), &error_code, sizeof(uint64_t));
+            dispatch_to_ruby(ctx->connection, ctx->connection_ctx, ctx->client_obj, "STOP_SENDING", stream_id, combined, sizeof(combined), 0);
             break;
+        }
     }
 
     return QUIC_STATUS_SUCCESS;
@@ -243,7 +416,7 @@ ConnectionCallback(HQUIC Connection, void* Context, QUIC_CONNECTION_EVENT* Event
             ctx->connected = 1;
             ctx->failed = 0;
             // Notify Ruby about new connection - pass ctx pointer for building connection_data
-            enqueue_callback_event(Connection, ctx, ctx->client_obj, "CONNECTION_ESTABLISHED", 0, (const char*)&Connection, sizeof(HQUIC));
+            dispatch_to_ruby(Connection, ctx, ctx->client_obj, "CONNECTION_ESTABLISHED", 0, (const char*)&Connection, sizeof(HQUIC), 0);
             break;
         case QUIC_CONNECTION_EVENT_SHUTDOWN_INITIATED_BY_TRANSPORT:
             ctx->connected = 0;
@@ -259,8 +432,13 @@ ConnectionCallback(HQUIC Connection, void* Context, QUIC_CONNECTION_EVENT* Event
             break;
         case QUIC_CONNECTION_EVENT_SHUTDOWN_COMPLETE:
             ctx->connected = 0;
-            // Notify Ruby to clean up connection resources
-            enqueue_callback_event(Connection, ctx, ctx->client_obj, "CONNECTION_CLOSED", 0, (const char*)&Connection, sizeof(HQUIC));
+            dispatch_to_ruby(Connection, ctx, ctx->client_obj, "CONNECTION_CLOSED", 0, (const char*)&Connection, sizeof(HQUIC), 0);
+            // Free context for all connections (both client and server).
+            // Client GC registration must be removed before freeing.
+            if (!NIL_P(ctx->client_obj)) {
+                rb_gc_unregister_address(&ctx->client_obj);
+            }
+            free(ctx);
             break;
          case QUIC_CONNECTION_EVENT_PEER_STREAM_STARTED:
             // Client opened a stream
@@ -272,10 +450,13 @@ ConnectionCallback(HQUIC Connection, void* Context, QUIC_CONNECTION_EVENT* Event
                 stream_ctx->client_obj = ctx->client_obj;  // Copy from connection context
                 stream_ctx->started = 1;
                 stream_ctx->shutdown = 0;
+                stream_ctx->early_data = 0;
                 stream_ctx->error_status = QUIC_STATUS_SUCCESS;
 
                 // Set the stream callback handler to handle data events
                 MsQuic->SetCallbackHandler(Stream, (void*)StreamCallback, stream_ctx);
+            } else {
+                MsQuic->StreamClose(Stream);
             }
          break; 
         default:
@@ -350,15 +531,67 @@ quicsilver_open(VALUE self)
         rb_raise(rb_eRuntimeError, "MsQuicOpenVersion failed, 0x%x!", Status);
         return Qfalse;
     }
-    
-    // Create a registration for the app's connections
+
+    // Custom execution MUST be set up BEFORE RegistrationOpen.
+    // RegistrationOpen triggers MsQuic lazy init (LazyInitComplete=TRUE),
+    // after which ExecutionCreate returns QUIC_STATUS_INVALID_STATE.
+#if __linux__
+    EventQ = epoll_create1(0);
+#elif __APPLE__ || __FreeBSD__
+    EventQ = kqueue();
+#endif
+    if (EventQ == -1) {
+        MsQuicClose(MsQuic);
+        MsQuic = NULL;
+        rb_raise(rb_eRuntimeError, "Failed to create event queue for custom execution");
+        return Qfalse;
+    }
+
+    QUIC_EXECUTION_CONFIG exec_config = { 0, &EventQ };
+    Status = MsQuic->ExecutionCreate(
+        QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_NONE,
+        0,      // PollingIdleTimeoutUs
+        1,      // 1 execution context
+        &exec_config,
+        &ExecContext
+    );
+    if (QUIC_FAILED(Status)) {
+        close(EventQ);
+        EventQ = -1;
+        MsQuicClose(MsQuic);
+        MsQuic = NULL;
+        rb_raise(rb_eRuntimeError, "ExecutionCreate failed, 0x%x!", Status);
+        return Qfalse;
+    }
+
+    // Now open registration — MsQuic lazy init will see the custom execution
+    // context and skip spawning its own worker threads.
     if (QUIC_FAILED(Status = MsQuic->RegistrationOpen(&RegConfig, &Registration))) {
-        rb_raise(rb_eRuntimeError, "RegistrationOpen failed, 0x%x!", Status);
+        MsQuic->ExecutionDelete(1, &ExecContext);
+        ExecContext = NULL;
+        close(EventQ);
+        EventQ = -1;
         MsQuicClose(MsQuic);
         MsQuic = NULL;
+        rb_raise(rb_eRuntimeError, "RegistrationOpen failed, 0x%x!", Status);
         return Qfalse;
     }
-    
+
+    // Register wake source — Ruby threads can unblock the event loop
+#if __linux__
+    WakeFd = eventfd(0, EFD_NONBLOCK);
+    if (WakeFd != -1) {
+        struct epoll_event ev = { .events = EPOLLIN, .data.ptr = NULL };
+        epoll_ctl(EventQ, EPOLL_CTL_ADD, WakeFd, &ev);
+    }
+#elif __APPLE__ || __FreeBSD__
+    {
+        struct kevent kev;
+        EV_SET(&kev, WAKE_IDENT, EVFILT_USER, EV_ADD | EV_CLEAR, 0, 0, NULL);
+        kevent(EventQ, &kev, 1, NULL, 0, NULL);
+    }
+#endif
+
     return Qtrue;
 }
 
@@ -398,11 +631,11 @@ quicsilver_create_configuration(VALUE self, VALUE unsecure)
     }
     
     if (QUIC_FAILED(Status = MsQuic->ConfigurationLoadCredential(Configuration, &CredConfig))) {
-        rb_raise(rb_eRuntimeError, "ConfigurationLoadCredential failed, 0x%x!", Status);
         MsQuic->ConfigurationClose(Configuration);
+        rb_raise(rb_eRuntimeError, "ConfigurationLoadCredential failed, 0x%x!", Status);
         return Qnil;
     }
-    
+
     // Return the configuration handle as a Ruby integer (pointer)
     return ULL2NUM((uintptr_t)Configuration);
 }
@@ -417,14 +650,24 @@ quicsilver_create_server_configuration(VALUE self, VALUE config_hash)
     }
     VALUE cert_file_val = rb_hash_aref(config_hash, ID2SYM(rb_intern("cert_file")));
     VALUE key_file_val = rb_hash_aref(config_hash, ID2SYM(rb_intern("key_file")));
-    VALUE idle_timeout_val = rb_hash_aref(config_hash, ID2SYM(rb_intern("idle_timeout")));
+    VALUE idle_timeout_val = rb_hash_aref(config_hash, ID2SYM(rb_intern("idle_timeout_ms")));
     VALUE server_resumption_level_val = rb_hash_aref(config_hash, ID2SYM(rb_intern("server_resumption_level")));
-    VALUE peer_bidi_stream_count_val = rb_hash_aref(config_hash, ID2SYM(rb_intern("peer_bidi_stream_count")));
-    VALUE peer_unidi_stream_count_val = rb_hash_aref(config_hash, ID2SYM(rb_intern("peer_unidi_stream_count")));
+    VALUE max_concurrent_requests_val = rb_hash_aref(config_hash, ID2SYM(rb_intern("max_concurrent_requests")));
+    VALUE max_unidirectional_streams_val = rb_hash_aref(config_hash, ID2SYM(rb_intern("max_unidirectional_streams")));
     VALUE alpn_val = rb_hash_aref(config_hash, ID2SYM(rb_intern("alpn")));
-    VALUE stream_recv_window_val = rb_hash_aref(config_hash, ID2SYM(rb_intern("stream_recv_window")));
-    VALUE stream_recv_buffer_val = rb_hash_aref(config_hash, ID2SYM(rb_intern("stream_recv_buffer")));
-    VALUE conn_flow_control_window_val = rb_hash_aref(config_hash, ID2SYM(rb_intern("conn_flow_control_window")));
+    VALUE stream_receive_window_val = rb_hash_aref(config_hash, ID2SYM(rb_intern("stream_receive_window")));
+    VALUE stream_receive_buffer_val = rb_hash_aref(config_hash, ID2SYM(rb_intern("stream_receive_buffer")));
+    VALUE connection_flow_control_window_val = rb_hash_aref(config_hash, ID2SYM(rb_intern("connection_flow_control_window")));
+    VALUE pacing_enabled_val = rb_hash_aref(config_hash, ID2SYM(rb_intern("pacing_enabled")));
+    VALUE send_buffering_enabled_val = rb_hash_aref(config_hash, ID2SYM(rb_intern("send_buffering_enabled")));
+    VALUE initial_rtt_ms_val = rb_hash_aref(config_hash, ID2SYM(rb_intern("initial_rtt_ms")));
+    VALUE initial_window_packets_val = rb_hash_aref(config_hash, ID2SYM(rb_intern("initial_window_packets")));
+    VALUE max_ack_delay_ms_val = rb_hash_aref(config_hash, ID2SYM(rb_intern("max_ack_delay_ms")));
+    VALUE keep_alive_interval_ms_val = rb_hash_aref(config_hash, ID2SYM(rb_intern("keep_alive_interval_ms")));
+    VALUE congestion_control_val = rb_hash_aref(config_hash, ID2SYM(rb_intern("congestion_control_algorithm")));
+    VALUE migration_enabled_val = rb_hash_aref(config_hash, ID2SYM(rb_intern("migration_enabled")));
+    VALUE disconnect_timeout_ms_val = rb_hash_aref(config_hash, ID2SYM(rb_intern("disconnect_timeout_ms")));
+    VALUE handshake_idle_timeout_ms_val = rb_hash_aref(config_hash, ID2SYM(rb_intern("handshake_idle_timeout_ms")));
 
     QUIC_STATUS Status;
     HQUIC Configuration = NULL;
@@ -433,31 +676,65 @@ quicsilver_create_server_configuration(VALUE self, VALUE config_hash)
     const char* key_path = StringValueCStr(key_file_val);
     uint32_t idle_timeout_ms = NUM2INT(idle_timeout_val);
     uint32_t server_resumption_level = NUM2INT(server_resumption_level_val);
-    uint32_t peer_bidi_stream_count = NUM2INT(peer_bidi_stream_count_val);
-    uint32_t peer_unidi_stream_count = NUM2INT(peer_unidi_stream_count_val);
+    uint32_t max_concurrent_requests = NUM2INT(max_concurrent_requests_val);
+    uint32_t max_unidirectional_streams = NUM2INT(max_unidirectional_streams_val);
     const char* alpn_str = StringValueCStr(alpn_val);
-    uint32_t stream_recv_window = NUM2UINT(stream_recv_window_val);
-    uint32_t stream_recv_buffer = NUM2UINT(stream_recv_buffer_val);
-    uint32_t conn_flow_control_window = NUM2UINT(conn_flow_control_window_val);
+    uint32_t stream_receive_window = NUM2UINT(stream_receive_window_val);
+    uint32_t stream_receive_buffer = NUM2UINT(stream_receive_buffer_val);
+    uint32_t connection_flow_control_window = NUM2UINT(connection_flow_control_window_val);
+    uint8_t pacing_enabled = (uint8_t)NUM2INT(pacing_enabled_val);
+    uint8_t send_buffering_enabled = (uint8_t)NUM2INT(send_buffering_enabled_val);
+    uint32_t initial_rtt_ms = NUM2UINT(initial_rtt_ms_val);
+    uint32_t initial_window_packets = NUM2UINT(initial_window_packets_val);
+    uint32_t max_ack_delay_ms = NUM2UINT(max_ack_delay_ms_val);
+    uint32_t keep_alive_interval_ms = NUM2UINT(keep_alive_interval_ms_val);
+    uint16_t congestion_control = (uint16_t)NUM2INT(congestion_control_val);
+    uint8_t migration_enabled = (uint8_t)NUM2INT(migration_enabled_val);
+    uint32_t disconnect_timeout_ms = NUM2UINT(disconnect_timeout_ms_val);
+    uint64_t handshake_idle_timeout_ms = NUM2ULL(handshake_idle_timeout_ms_val);
 
     QUIC_SETTINGS Settings = {0};
     Settings.IdleTimeoutMs = idle_timeout_ms;
     Settings.IsSet.IdleTimeoutMs = TRUE;
     Settings.ServerResumptionLevel = server_resumption_level;
     Settings.IsSet.ServerResumptionLevel = TRUE;
-    Settings.PeerBidiStreamCount = peer_bidi_stream_count;
+    Settings.PeerBidiStreamCount = max_concurrent_requests;
     Settings.IsSet.PeerBidiStreamCount = TRUE;
-    Settings.PeerUnidiStreamCount = peer_unidi_stream_count;
+    Settings.PeerUnidiStreamCount = max_unidirectional_streams;
     Settings.IsSet.PeerUnidiStreamCount = TRUE;
 
     // Flow control / backpressure settings
-    Settings.StreamRecvWindowDefault = stream_recv_window;
+    Settings.StreamRecvWindowDefault = stream_receive_window;
     Settings.IsSet.StreamRecvWindowDefault = TRUE;
-    Settings.StreamRecvBufferDefault = stream_recv_buffer;
+    Settings.StreamRecvBufferDefault = stream_receive_buffer;
     Settings.IsSet.StreamRecvBufferDefault = TRUE;
-    Settings.ConnFlowControlWindow = conn_flow_control_window;
+    Settings.ConnFlowControlWindow = connection_flow_control_window;
     Settings.IsSet.ConnFlowControlWindow = TRUE;
 
+    // Throughput settings
+    Settings.PacingEnabled = pacing_enabled;
+    Settings.IsSet.PacingEnabled = TRUE;
+    Settings.SendBufferingEnabled = send_buffering_enabled;
+    Settings.IsSet.SendBufferingEnabled = TRUE;
+    Settings.InitialRttMs = initial_rtt_ms;
+    Settings.IsSet.InitialRttMs = TRUE;
+    Settings.InitialWindowPackets = initial_window_packets;
+    Settings.IsSet.InitialWindowPackets = TRUE;
+    Settings.MaxAckDelayMs = max_ack_delay_ms;
+    Settings.IsSet.MaxAckDelayMs = TRUE;
+
+    // Connection management
+    Settings.KeepAliveIntervalMs = keep_alive_interval_ms;
+    Settings.IsSet.KeepAliveIntervalMs = TRUE;
+    Settings.CongestionControlAlgorithm = congestion_control;
+    Settings.IsSet.CongestionControlAlgorithm = TRUE;
+    Settings.MigrationEnabled = migration_enabled;
+    Settings.IsSet.MigrationEnabled = TRUE;
+    Settings.DisconnectTimeoutMs = disconnect_timeout_ms;
+    Settings.IsSet.DisconnectTimeoutMs = TRUE;
+    Settings.HandshakeIdleTimeoutMs = handshake_idle_timeout_ms;
+    Settings.IsSet.HandshakeIdleTimeoutMs = TRUE;
+
     QUIC_BUFFER Alpn = { (uint32_t)strlen(alpn_str), (uint8_t*)alpn_str };
     
     // Create configuration
@@ -478,8 +755,8 @@ quicsilver_create_server_configuration(VALUE self, VALUE config_hash)
     CredConfig.Flags = QUIC_CREDENTIAL_FLAG_NO_CERTIFICATE_VALIDATION;
     
     if (QUIC_FAILED(Status = MsQuic->ConfigurationLoadCredential(Configuration, &CredConfig))) {
-        rb_raise(rb_eRuntimeError, "Server ConfigurationLoadCredential failed, 0x%x!", Status);
         MsQuic->ConfigurationClose(Configuration);
+        rb_raise(rb_eRuntimeError, "Server ConfigurationLoadCredential failed, 0x%x!", Status);
         return Qnil;
     }
     
@@ -553,7 +830,8 @@ quicsilver_start_connection(VALUE self, VALUE connection_handle, VALUE config_ha
         rb_raise(rb_eRuntimeError, "ConnectionStart failed, 0x%x!", Status);
         return Qfalse;
     }
-    
+
+    wake_event_loop();
     return Qtrue;
 }
 
@@ -567,7 +845,7 @@ quicsilver_wait_for_connection(VALUE self, VALUE context_handle, VALUE timeout_m
     const int sleep_interval = 10; // 10ms
     
     while (elapsed < timeout && !ctx->connected && !ctx->failed) {
-        usleep(sleep_interval * 1000); // Convert to microseconds
+        poll_inline(sleep_interval);  // Drive MsQuic execution while waiting
         elapsed += sleep_interval;
     }
     
@@ -618,21 +896,29 @@ quicsilver_close_connection_handle(VALUE self, VALUE connection_data)
     VALUE context_handle = rb_ary_entry(connection_data, 1);
 
     HQUIC Connection = (HQUIC)(uintptr_t)NUM2ULL(connection_handle);
-    ConnectionContext* ctx = (ConnectionContext*)(uintptr_t)NUM2ULL(context_handle);
+    (void)context_handle; // ctx freed by SHUTDOWN_COMPLETE, not here
 
     if (Connection != NULL) {
         MsQuic->ConnectionClose(Connection);
     }
 
-    // Free context if valid
-    if (ctx != NULL) {
-        // Unregister from GC if client object was set
-        if (!NIL_P(ctx->client_obj)) {
-            rb_gc_unregister_address(&ctx->client_obj);
-        }
-        free(ctx);
-    }
+    // Don't free ctx here — ConnectionClose is async and SHUTDOWN_COMPLETE
+    // will fire on the next event loop poll, which still needs ctx.
+    // SHUTDOWN_COMPLETE handles cleanup for both client and server.
+
+    return Qnil;
+}
+
+// Close a server-side connection handle (context already freed in C callback)
+static VALUE
+quicsilver_close_server_connection(VALUE self, VALUE connection_handle)
+{
+    if (MsQuic == NULL) return Qnil;
 
+    HQUIC Connection = (HQUIC)(uintptr_t)NUM2ULL(connection_handle);
+    if (Connection != NULL) {
+        MsQuic->ConnectionClose(Connection);
+    }
     return Qnil;
 }
 
@@ -656,6 +942,7 @@ quicsilver_connection_shutdown(VALUE self, VALUE connection_handle, VALUE error_
             : QUIC_CONNECTION_SHUTDOWN_FLAG_NONE;
 
         MsQuic->ConnectionShutdown(Connection, flags, ErrorCode);
+        wake_event_loop();
     }
 
     return Qtrue;
@@ -674,20 +961,35 @@ quicsilver_close_configuration(VALUE self, VALUE config_handle)
     return Qnil;
 }
 
-// Close MSQUIC
 static VALUE
 quicsilver_close(VALUE self)
 {
     if (MsQuic != NULL) {
         if (Registration != NULL) {
-            // This will block until all outstanding child objects have been closed
             MsQuic->RegistrationClose(Registration);
             Registration = NULL;
         }
+
+        if (ExecContext != NULL) {
+            MsQuic->ExecutionDelete(1, &ExecContext);
+            ExecContext = NULL;
+        }
+
         MsQuicClose(MsQuic);
         MsQuic = NULL;
     }
-    
+
+#if __linux__
+    if (WakeFd != -1) {
+        close(WakeFd);
+        WakeFd = -1;
+    }
+#endif
+    if (EventQ != -1) {
+        close(EventQ);
+        EventQ = -1;
+    }
+
     return Qnil;
 }
 
@@ -733,34 +1035,42 @@ quicsilver_create_listener(VALUE self, VALUE config_handle)
 
 // Start listener on specific address and port
 static VALUE
-quicsilver_start_listener(VALUE self, VALUE listener_handle, VALUE address, VALUE port)
+quicsilver_start_listener(VALUE self, VALUE listener_handle, VALUE address, VALUE port, VALUE alpn)
 {
     if (MsQuic == NULL) {
         rb_raise(rb_eRuntimeError, "MSQUIC not initialized.");
         return Qfalse;
     }
-    
+
     HQUIC Listener = (HQUIC)(uintptr_t)NUM2ULL(listener_handle);
     uint16_t Port = (uint16_t)NUM2INT(port);
-    
+    const char* alpn_str = StringValueCStr(alpn);
+
     // Setup address - properly initialize the entire structure
     QUIC_ADDR Address;
     memset(&Address, 0, sizeof(Address));
-    
-    // Set up for localhost/any address
-    QuicAddrSetFamily(&Address, QUIC_ADDRESS_FAMILY_INET);
+
+    // Parse address string to determine family
+    const char* addr_str = StringValueCStr(address);
+    if (strchr(addr_str, ':') != NULL) {
+        // IPv6 address (contains ':')
+        QuicAddrSetFamily(&Address, QUIC_ADDRESS_FAMILY_INET6);
+    } else {
+        // IPv4 address or unspecified - use UNSPEC for dual-stack
+        QuicAddrSetFamily(&Address, QUIC_ADDRESS_FAMILY_UNSPEC);
+    }
     QuicAddrSetPort(&Address, Port);
-    
+
     QUIC_STATUS Status;
-    
-    // Create QUIC_BUFFER for the address
-    QUIC_BUFFER AlpnBuffer = { sizeof("h3") - 1, (uint8_t*)"h3" };
-    
+
+    QUIC_BUFFER AlpnBuffer = { (uint32_t)strlen(alpn_str), (uint8_t*)alpn_str };
+
     if (QUIC_FAILED(Status = MsQuic->ListenerStart(Listener, &AlpnBuffer, 1, &Address))) {
         rb_raise(rb_eRuntimeError, "ListenerStart failed, 0x%x!", Status);
         return Qfalse;
     }
-    
+
+    wake_event_loop();
     return Qtrue;
 }
 
@@ -771,9 +1081,10 @@ quicsilver_stop_listener(VALUE self, VALUE listener_handle)
     if (MsQuic == NULL) {
         return Qfalse;
     }
-    
+
     HQUIC Listener = (HQUIC)(uintptr_t)NUM2ULL(listener_handle);
     MsQuic->ListenerStop(Listener);
+    wake_event_loop();
     return Qtrue;
 }
 
@@ -830,6 +1141,7 @@ quicsilver_open_stream(VALUE self, VALUE connection_data, VALUE unidirectional)
     ctx->client_obj = conn_ctx ? conn_ctx->client_obj : Qnil;
     ctx->started = 1;
     ctx->shutdown = 0;
+    ctx->early_data = 0;
     ctx->error_status = QUIC_STATUS_SUCCESS;
 
     // Use flag based on parameter
@@ -848,12 +1160,13 @@ quicsilver_open_stream(VALUE self, VALUE connection_data, VALUE unidirectional)
     // Start the stream
     Status = MsQuic->StreamStart(Stream, QUIC_STREAM_START_FLAG_NONE);
     if (QUIC_FAILED(Status)) {
-        free(ctx);
+        // StreamClose fires SHUTDOWN_COMPLETE synchronously which frees ctx
         MsQuic->StreamClose(Stream);
         rb_raise(rb_eRuntimeError, "StreamStart failed, 0x%x!", Status);
         return Qnil;
     }
-    
+
+    wake_event_loop();
     return ULL2NUM((uintptr_t)Stream);
 }
 
@@ -894,9 +1207,78 @@ quicsilver_send_stream(VALUE self, VALUE stream_handle, VALUE data, VALUE send_f
         rb_raise(rb_eRuntimeError, "StreamSend failed, 0x%x!", Status);
         return Qfalse;
     }
-    
+
+    wake_event_loop();
+    return Qtrue;
+}
+
+// Reset a QUIC stream (RESET_STREAM frame - abruptly terminates sending)
+static VALUE
+quicsilver_stream_reset(VALUE self, VALUE stream_handle, VALUE error_code)
+{
+    if (MsQuic == NULL) {
+        rb_raise(rb_eRuntimeError, "MSQUIC not initialized.");
+        return Qnil;
+    }
+
+    HQUIC Stream = (HQUIC)(uintptr_t)NUM2ULL(stream_handle);
+    if (Stream == NULL) return Qnil;
+
+    uint64_t ErrorCode = NUM2ULL(error_code);
+
+    MsQuic->StreamShutdown(Stream, QUIC_STREAM_SHUTDOWN_FLAG_ABORT_SEND, ErrorCode);
+
+    wake_event_loop();
     return Qtrue;
-}  
+}
+
+// Queue a stream priority change. Called from Ruby threads — just stores the
+// priority. The actual SetParam happens on the MsQuic event thread in StreamCallback.
+static VALUE
+quicsilver_set_stream_priority(VALUE self, VALUE stream_handle, VALUE priority)
+{
+    if (MsQuic == NULL) return Qnil;
+
+    HQUIC Stream = (HQUIC)(uintptr_t)NUM2ULL(stream_handle);
+    if (Stream == NULL) return Qnil;
+
+    if (PendingPriorityCount >= MAX_PENDING_PRIORITIES) return Qfalse;
+
+    uint16_t Priority = (uint16_t)NUM2UINT(priority);
+    PendingPriorities[PendingPriorityCount].stream = Stream;
+    PendingPriorities[PendingPriorityCount].priority_plus_one = Priority + 1;
+    PendingPriorityCount++;
+
+    wake_event_loop();
+    return Qtrue;
+}
+
+// Stop sending on a QUIC stream (STOP_SENDING frame - requests peer to stop)
+static VALUE
+quicsilver_stream_stop_sending(VALUE self, VALUE stream_handle, VALUE error_code)
+{
+    if (MsQuic == NULL) {
+        rb_raise(rb_eRuntimeError, "MSQUIC not initialized.");
+        return Qnil;
+    }
+
+    HQUIC Stream = (HQUIC)(uintptr_t)NUM2ULL(stream_handle);
+    if (Stream == NULL) return Qnil;
+
+    uint64_t ErrorCode = NUM2ULL(error_code);
+
+    MsQuic->StreamShutdown(Stream, QUIC_STREAM_SHUTDOWN_FLAG_ABORT_RECEIVE, ErrorCode);
+
+    wake_event_loop();
+    return Qtrue;
+}
+
+static VALUE
+quicsilver_wake(VALUE self)
+{
+    wake_event_loop();
+    return Qnil;
+}
 
 // Initialize the extension
 void
@@ -920,17 +1302,22 @@ Init_quicsilver(void)
     rb_define_singleton_method(mQuicsilver, "connection_status", quicsilver_connection_status, 1);
     rb_define_singleton_method(mQuicsilver, "connection_shutdown", quicsilver_connection_shutdown, 3);
     rb_define_singleton_method(mQuicsilver, "close_connection_handle", quicsilver_close_connection_handle, 1);
+    rb_define_singleton_method(mQuicsilver, "close_server_connection", quicsilver_close_server_connection, 1);
     
     // Listener management
     rb_define_singleton_method(mQuicsilver, "create_listener", quicsilver_create_listener, 1);
-    rb_define_singleton_method(mQuicsilver, "start_listener", quicsilver_start_listener, 3);
+    rb_define_singleton_method(mQuicsilver, "start_listener", quicsilver_start_listener, 4);
     rb_define_singleton_method(mQuicsilver, "stop_listener", quicsilver_stop_listener, 1);
     rb_define_singleton_method(mQuicsilver, "close_listener", quicsilver_close_listener, 1);
 
     // Stream management
     rb_define_singleton_method(mQuicsilver, "open_stream", quicsilver_open_stream, 2);
     rb_define_singleton_method(mQuicsilver, "send_stream", quicsilver_send_stream, 3);
+    rb_define_singleton_method(mQuicsilver, "stream_reset", quicsilver_stream_reset, 2);
+    rb_define_singleton_method(mQuicsilver, "stream_stop_sending", quicsilver_stream_stop_sending, 2);
+    rb_define_singleton_method(mQuicsilver, "set_stream_priority", quicsilver_set_stream_priority, 2);
 
-    // Event processing
-    rb_define_singleton_method(mQuicsilver, "process_events", quicsilver_process_events, 0);
+    // Event processing (custom execution — app drives MsQuic)
+    rb_define_singleton_method(mQuicsilver, "poll", quicsilver_poll, 0);
+    rb_define_singleton_method(mQuicsilver, "wake", quicsilver_wake, 0);
 }