io-event 1.22.1 → 1.22.3

data/ext/io/event/selector/uring.c

@@ -3,6 +3,7 @@
 
 #include "uring.h"
 #include "selector.h"
+#include "../futex.h"
 #include "../list.h"
 #include "../array.h"
 
@@ -804,6 +805,190 @@ VALUE IO_Event_Selector_URing_process_wait(VALUE self, VALUE fiber, VALUE _pid,
 	return rb_ensure(process_wait_transfer, (VALUE)&process_wait_arguments, process_wait_ensure, (VALUE)&process_wait_arguments);
 }
 
+#if defined(IO_EVENT_FUTEX) && defined(HAVE_IO_URING_PREP_FUTEX_WAIT)
+
+#pragma mark - Futex Wait
+
+struct futex_wait_arguments {
+	struct IO_Event_Selector_URing *selector;
+	struct IO_Event_Selector_URing_Waiting waiting;
+	VALUE futex;
+	uint32_t expected;
+	bool acquired;
+	bool submitted;
+};
+
+static VALUE futex_wait_cancel(VALUE _arguments) {
+	struct futex_wait_arguments *arguments = (struct futex_wait_arguments *)_arguments;
+	if (arguments->submitted) {
+		// Drain the original operation before releasing its futex. The shared
+		// helper tracks cancellation CQEs to prevent premature completion reuse.
+		IO_Event_Selector_URing_Waiting_cancel_and_wait(arguments->selector, &arguments->waiting);
+	} else if (arguments->waiting.completion) {
+		// Setup failed before an SQE referred to this completion.
+		IO_Event_Selector_URing_Completion_complete(arguments->selector, arguments->waiting.completion);
+	}
+	return Qnil;
+}
+
+static VALUE futex_wait_release(VALUE _arguments) {
+	struct futex_wait_arguments *arguments = (struct futex_wait_arguments *)_arguments;
+	if (arguments->acquired) {
+		IO_Event_Futex_release(arguments->futex);
+		arguments->acquired = false;
+	}
+	return Qnil;
+}
+
+static VALUE futex_wait_ensure(VALUE _arguments) {
+	return rb_ensure(futex_wait_cancel, _arguments, futex_wait_release, _arguments);
+}
+
+static VALUE futex_wait_transfer(VALUE _arguments) {
+	struct futex_wait_arguments *arguments = (struct futex_wait_arguments *)_arguments;
+	uint32_t *address = IO_Event_Futex_acquire(arguments->futex);
+	arguments->acquired = true;
+
+	// Arguments have been coerced and the futex is now held open. From here
+	// on, the enclosing ensure owns all completion and cancellation cleanup.
+	struct IO_Event_Selector_URing_Completion *completion = IO_Event_Selector_URing_Completion_acquire(arguments->selector, &arguments->waiting);
+	struct io_uring_sqe *sqe = io_get_sqe(arguments->selector);
+	io_uring_prep_futex_wait(sqe, address, arguments->expected, FUTEX_BITSET_MATCH_ANY, FUTEX2_SIZE_U32, 0);
+	io_uring_sqe_set_data(sqe, completion);
+	arguments->submitted = true;
+	io_uring_submit_pending(arguments->selector);
+
+	IO_Event_Selector_loop_yield(&arguments->selector->backend);
+	if (arguments->waiting.completion) {
+		// An out-of-band resume is not a successful futex notification.
+		IO_Event_Selector_URing_Waiting_cancel_and_wait(arguments->selector, &arguments->waiting);
+	}
+
+	int32_t result = arguments->waiting.result;
+	if (result >= 0) {
+		return Qtrue;
+	} else if (result == -EAGAIN || result == -ECANCELED) {
+		return Qfalse;
+	} else {
+		rb_syserr_fail(-result, "futex_wait_transfer:io_uring_futex_wait");
+	}
+	
+	return Qnil;
+}
+
+static VALUE IO_Event_Selector_URing_futex_wait(VALUE self, VALUE fiber, VALUE futex, VALUE expected_value) {
+	struct IO_Event_Selector_URing *selector = NULL;
+	TypedData_Get_Struct(self, struct IO_Event_Selector_URing, &IO_Event_Selector_URing_Type, selector);
+	struct futex_wait_arguments arguments = {
+		.selector = selector,
+		.waiting = {.fiber = fiber},
+		.futex = futex,
+		.expected = NUM2UINT(expected_value),
+	};
+	RB_OBJ_WRITTEN(self, Qundef, fiber);
+	VALUE result = rb_ensure(futex_wait_transfer, (VALUE)&arguments, futex_wait_ensure, (VALUE)&arguments);
+	RB_GC_GUARD(futex);
+	return result;
+}
+
+#if defined(IO_EVENT_FUTEX_WAITV) && defined(HAVE_IO_URING_PREP_FUTEX_WAITV)
+
+#pragma mark - Futex Vector Wait
+
+struct futex_waitv_arguments {
+	struct IO_Event_Selector_URing *selector;
+	struct IO_Event_Selector_URing_Waiting waiting;
+	VALUE futexes;
+	struct futex_waitv *vector;
+	long count;
+	long acquired;
+	bool submitted;
+};
+
+static VALUE futex_waitv_cancel(VALUE _arguments) {
+	struct futex_waitv_arguments *arguments = (struct futex_waitv_arguments *)_arguments;
+	if (arguments->submitted) {
+		// Drain the original operation before releasing its futex references or
+		// stack-backed wait vector. The shared helper also tracks cancellation
+		// CQEs so the completion record cannot be reused prematurely.
+		IO_Event_Selector_URing_Waiting_cancel_and_wait(arguments->selector, &arguments->waiting);
+	} else if (arguments->waiting.completion) {
+		// Setup failed before an SQE referred to this completion.
+		IO_Event_Selector_URing_Completion_complete(arguments->selector, arguments->waiting.completion);
+	}
+	return Qnil;
+}
+
+static VALUE futex_waitv_release(VALUE _arguments) {
+	struct futex_waitv_arguments *arguments = (struct futex_waitv_arguments *)_arguments;
+	while (arguments->acquired) {
+		IO_Event_Futex_release(RARRAY_AREF(arguments->futexes, --arguments->acquired));
+	}
+	return Qnil;
+}
+
+static VALUE futex_waitv_ensure(VALUE _arguments) {
+	return rb_ensure(futex_waitv_cancel, _arguments, futex_waitv_release, _arguments);
+}
+
+static VALUE futex_waitv_transfer(VALUE _arguments) {
+	struct futex_waitv_arguments *arguments = (struct futex_waitv_arguments *)_arguments;
+	while (arguments->acquired < arguments->count) {
+		long index = arguments->acquired;
+		arguments->vector[index].uaddr = (uintptr_t)IO_Event_Futex_acquire(RARRAY_AREF(arguments->futexes, index));
+		arguments->acquired += 1;
+	}
+
+	// Arguments have been coerced and every futex is now held open. The
+	// enclosing ensure also releases entries if acquisition fails partway.
+	struct IO_Event_Selector_URing_Completion *completion = IO_Event_Selector_URing_Completion_acquire(arguments->selector, &arguments->waiting);
+	struct io_uring_sqe *sqe = io_get_sqe(arguments->selector);
+	io_uring_prep_futex_waitv(sqe, arguments->vector, arguments->count, 0);
+	io_uring_sqe_set_data(sqe, completion);
+	arguments->submitted = true;
+	io_uring_submit_pending(arguments->selector);
+
+	IO_Event_Selector_loop_yield(&arguments->selector->backend);
+	if (arguments->waiting.completion) {
+		// An out-of-band resume is not a successful futex notification.
+		IO_Event_Selector_URing_Waiting_cancel_and_wait(arguments->selector, &arguments->waiting);
+	}
+
+	int32_t result = arguments->waiting.result;
+	if (result >= 0) {
+		return INT2NUM(result);
+	} else if (result == -EAGAIN || result == -ECANCELED) {
+		return Qnil;
+	} else {
+		rb_syserr_fail(-result, "futex_waitv_transfer:io_uring_futex_waitv");
+	}
+
+	return Qnil;
+}
+
+static VALUE IO_Event_Selector_URing_futex_waitv(VALUE self, VALUE fiber, VALUE entries) {
+	struct IO_Event_Selector_URing *selector = NULL;
+	TypedData_Get_Struct(self, struct IO_Event_Selector_URing, &IO_Event_Selector_URing_Type, selector);
+	
+	struct futex_waitv vector[FUTEX_WAITV_MAX];
+	VALUE futexes = IO_Event_Futex_prepare_waitv(entries, vector);
+	struct futex_waitv_arguments arguments = {
+		.selector = selector,
+		.waiting = {.fiber = fiber},
+		.futexes = futexes,
+		.vector = vector,
+		.count = RARRAY_LEN(futexes),
+	};
+	RB_OBJ_WRITTEN(self, Qundef, fiber);
+	VALUE result = rb_ensure(futex_waitv_transfer, (VALUE)&arguments, futex_waitv_ensure, (VALUE)&arguments);
+	RB_GC_GUARD(futexes);
+	return result;
+}
+
+#endif
+
+#endif
+
 #pragma mark - IO#wait
 
 static inline
@@ -1724,6 +1909,9 @@ VALUE IO_Event_Selector_URing_wakeup(VALUE self) {
 
 #pragma mark - Native Methods
 
+static int IO_Event_Selector_URing_futex_supported = 0;
+static int IO_Event_Selector_URing_futex_waitv_supported = 0;
+
 static int IO_Event_Selector_URing_supported_p(void) {
 	struct io_uring ring;
 	
@@ -1754,6 +1942,17 @@ static int IO_Event_Selector_URing_supported_p(void) {
 		
 		return 0;
 	}
+
+#if defined(IO_EVENT_FUTEX) && defined(HAVE_IO_URING_PREP_FUTEX_WAIT)
+	struct io_uring_probe *probe = io_uring_get_probe_ring(&ring);
+	if (probe) {
+		IO_Event_Selector_URing_futex_supported = io_uring_opcode_supported(probe, IORING_OP_FUTEX_WAIT);
+#if defined(IO_EVENT_FUTEX_WAITV) && defined(HAVE_IO_URING_PREP_FUTEX_WAITV)
+		IO_Event_Selector_URing_futex_waitv_supported = io_uring_opcode_supported(probe, IORING_OP_FUTEX_WAITV);
+#endif
+		io_uring_free_probe(probe);
+	}
+#endif
 	
 	io_uring_queue_exit(&ring);
 	
@@ -1803,4 +2002,16 @@ void Init_IO_Event_Selector_URing(VALUE IO_Event_Selector) {
 	rb_define_method(IO_Event_Selector_URing, "io_close", IO_Event_Selector_URing_io_close, 1);
 	
 	rb_define_method(IO_Event_Selector_URing, "process_wait", IO_Event_Selector_URing_process_wait, 3);
+
+#if defined(IO_EVENT_FUTEX) && defined(HAVE_IO_URING_PREP_FUTEX_WAIT)
+	if (IO_Event_Selector_URing_futex_supported) {
+		rb_define_method(IO_Event_Selector_URing, "futex_wait", IO_Event_Selector_URing_futex_wait, 3);
+		
+#if defined(IO_EVENT_FUTEX_WAITV) && defined(HAVE_IO_URING_PREP_FUTEX_WAITV)
+		if (IO_Event_Selector_URing_futex_waitv_supported) {
+			rb_define_method(IO_Event_Selector_URing, "futex_waitv", IO_Event_Selector_URing_futex_waitv, 2);
+		}
+#endif
+	}
+#endif
 }

data/ext/io/event/worker_pool.c

@@ -1,5 +1,5 @@
 // Released under the MIT License.
-// Copyright, 2025, by Samuel Williams.
+// Copyright, 2025-2026, by Samuel Williams.
 
 #include "worker_pool.h"
 #include "worker_pool_test.h"
@@ -19,7 +19,9 @@ enum {
 };
 
 static VALUE IO_Event_WorkerPool;
+static VALUE rb_Fiber;
 static ID id_maximum_worker_count;
+static ID id_blocking;
 
 // Thread pool structure
 struct IO_Event_WorkerPool_Worker {
@@ -318,17 +320,11 @@ static VALUE worker_pool_work_block(VALUE _work) {
 static VALUE worker_pool_work_wait(VALUE _work) {
 	struct IO_Event_WorkerPool_Work *work = (void*)_work;
 
-	while (true) {
+	// A stale unblock is not cancellation. Only a non-local exit cancels work.
+	do {
 		worker_pool_work_block(_work);
 		if (DEBUG) fprintf(stderr, "-- worker_pool_work_wait:work completed=%d\n", work->completed);
-		
-		if (work->completed) {
-			break;
-		}
-		
-		if (DEBUG) fprintf(stderr, "worker_pool_work_wait:rb_fiber_scheduler_blocking_operation_cancel\n");
-		rb_fiber_scheduler_blocking_operation_cancel(work->blocking_operation);
-	}
+	} while (!work->completed);
 
 	return Qtrue;
 }
@@ -354,6 +350,21 @@ static VALUE worker_pool_work_ensure(VALUE _work) {
 	return Qnil;
 }
 
+static VALUE worker_pool_work_submit(RB_BLOCK_CALL_FUNC_ARGLIST(fiber, _work)) {
+	struct IO_Event_WorkerPool_Work *work = (void*)_work;
+	struct IO_Event_WorkerPool *pool;
+	TypedData_Get_Struct(work->blocker, struct IO_Event_WorkerPool, &IO_Event_WorkerPool_type, pool);
+	
+	pthread_mutex_lock(&pool->mutex);
+	enqueue_work(pool, work);
+	pthread_cond_signal(&pool->work_available);
+	pthread_mutex_unlock(&pool->mutex);
+	
+	// Keep cancellation and draining inside the blocking scope too. rb_ensure
+	// preserves the original exception or other non-local exit.
+	return rb_ensure(worker_pool_work_wait, _work, worker_pool_work_ensure, _work);
+}
+
 // Ruby method to submit work and wait for completion
 static VALUE worker_pool_call(VALUE self, VALUE _blocking_operation) {
 	struct IO_Event_WorkerPool *pool;
@@ -389,17 +400,13 @@ static VALUE worker_pool_call(VALUE self, VALUE _blocking_operation) {
 		.fiber = fiber,
 		.next = NULL
 	};
-		
-	// Enqueue work:
-	pthread_mutex_lock(&pool->mutex);
-	enqueue_work(pool, &work);
-	pthread_cond_signal(&pool->work_available);
-	pthread_mutex_unlock(&pool->mutex);
 	
-	// Block the current fiber until work is completed. If blocking exits via an
-	// exception or another non-local jump, ensure the work is cancelled and fully
-	// drained before Ruby restores and rethrows the original control-flow state.
-	return rb_ensure(worker_pool_work_wait, (VALUE)&work, worker_pool_work_ensure, (VALUE)&work);
+	// A finalizer inside the scheduler's block hook must not offload another
+	// operation on this fiber and consume this work's wakeup. Fiber.blocking
+	// makes nested operations synchronous, while explicit fiber transfers still
+	// work and other fibers retain their own blocking state. Capture the scheduler
+	// above, before Fiber.blocking hides it from rb_fiber_scheduler_current().
+	return rb_block_call(rb_Fiber, id_blocking, 0, NULL, worker_pool_work_submit, (VALUE)&work);
 }
 
 static VALUE worker_pool_allocate(VALUE klass) {
@@ -495,6 +502,9 @@ static VALUE worker_pool_statistics(VALUE self) {
 void Init_IO_Event_WorkerPool(VALUE IO_Event) {
 	// Initialize symbols
 	id_maximum_worker_count = rb_intern("maximum_worker_count");
+	id_blocking = rb_intern("blocking");
+	rb_Fiber = rb_const_get(rb_cObject, rb_intern("Fiber"));
+	rb_global_variable(&rb_Fiber);
 	
 	IO_Event_WorkerPool = rb_define_class_under(IO_Event, "WorkerPool", rb_cObject);
 	rb_define_alloc_func(IO_Event_WorkerPool, worker_pool_allocate);

data/ext/io/event/worker_pool_test.c

@@ -18,6 +18,7 @@ struct BusyOperationData {
   int read_fd;
   int write_fd;
   volatile int cancelled;
+  volatile int executed;
   double duration;  // How long to wait (for testing)
   clock_t start_time;
   clock_t end_time;
@@ -29,6 +30,9 @@ struct BusyOperationData {
 static void* busy_blocking_operation(void *data) {
 	struct BusyOperationData *busy_data = (struct BusyOperationData*)data;
 	
+	// Record that the operation actually ran (a cancelled operation may be skipped entirely):
+	busy_data->executed = 1;
+	
 	// Use select() to wait for the pipe to become readable
 	fd_set read_fds;
 	struct timeval timeout;
@@ -143,6 +147,7 @@ static VALUE worker_pool_test_busy(int argc, VALUE *argv, VALUE self) {
 		.read_fd = pipe_fds[0],
 		.write_fd = pipe_fds[1],
 		.cancelled = 0,
+		.executed = 0,
 		.duration = duration,
 		.start_time = 0,
 		.end_time = 0,
@@ -165,6 +170,7 @@ static VALUE worker_pool_test_busy(int argc, VALUE *argv, VALUE self) {
 	VALUE result = rb_hash_new();
 	rb_hash_aset(result, ID2SYM(rb_intern("duration")), DBL2NUM(duration));
 	rb_hash_aset(result, ID2SYM(rb_intern("elapsed")), DBL2NUM(elapsed));
+	rb_hash_aset(result, ID2SYM(rb_intern("executed")), busy_data.executed ? Qtrue : Qfalse);
 	
 	// Determine result based on operation outcome
 	if (busy_data.exception != Qnil) {

data/lib/io/event/debug/selector.rb

@@ -19,6 +19,18 @@ module IO::Event
 					log("Closing file descriptor #{descriptor}")
 					@selector.io_close(descriptor)
 				end
+				
+				# Wait for a futex value to change, forwarded to the underlying selector.
+				def futex_wait(fiber, futex, expected)
+					log("Waiting for futex #{futex.inspect} with value #{expected}")
+					@selector.futex_wait(fiber, futex, expected)
+				end
+				
+				# Wait for any futex value to change, forwarded to the underlying selector.
+				def futex_waitv(fiber, entries)
+					log("Waiting for futex vector #{entries.inspect}")
+					@selector.futex_waitv(fiber, entries)
+				end
 			end
 			
 			# Wrap the given selector with debugging.

data/lib/io/event/version.rb

@@ -7,6 +7,6 @@
 class IO
 	# @namespace
 	module Event
-		VERSION = "1.22.1"
+		VERSION = "1.22.3"
 	end
 end

data/license.md

@@ -20,6 +20,8 @@ Copyright, 2026, by Italo Brandão.
 Copyright, 2026, by Fletcher Dares.  
 Copyright, 2026, by Tavian Barnes.  
 Copyright, 2026, by Sharon Rosner.  
+Copyright, 2026, by Yuki Kikuchi.  
+Copyright, 2026, by Randy Stauner.  
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/readme.md

@@ -14,10 +14,21 @@ Please see the [project documentation](https://socketry.github.io/io-event/) for
 
   - [Getting Started](https://socketry.github.io/io-event/guides/getting-started/index) - This guide explains how to use `io-event` for non-blocking IO.
 
+  - [Futex Notifications](https://socketry.github.io/io-event/guides/futex/index) - This guide explains how to use `IO::Event::Futex` to notify threads or processes when shared state changes, without continuously polling it.
+
 ## Releases
 
 Please see the [project releases](https://socketry.github.io/io-event/releases/index) for all releases.
 
+### v1.22.3
+
+  - Sign releases with the shared Socketry certificate.
+
+### v1.22.2
+
+  - Prevent nested worker-pool waits by running `WorkerPool#call` in a `Fiber.blocking` scope. Blocking operations triggered inside scheduler callbacks, including finalizers, execute synchronously. Cancellation still drains submitted work, and spurious wakeups no longer cancel operations.
+  - Add `IO::Event::Futex` on Linux with Ruby 4.1+, including atomic value operations and blocking and scheduler-aware single and vector waits over shared memory. Futexes retain a counted allocation lock until explicitly closed or finalized; pending waits prevent closing until completion or cancellation has finished.
+
 ### v1.22.1
 
   - Fix an infinite loop in the ready queue flush when a queued fiber is resumed out of band, e.g. by a stale `unblock` racing a timeout, while another fiber re-queues itself on every iteration.
@@ -52,15 +63,6 @@ Please see the [project releases](https://socketry.github.io/io-event/releases/i
 
   - Use `rb_process_status_for` when available to construct `URing` `process_wait` results directly from `waitid`, avoiding the extra reap syscall previously needed to build a `Process::Status`.
 
-### v1.19.1
-
-  - Fix `Process.waitall` / `Process.detach` under the `URing` selector: when `io_uring`'s `waitid` reported an error (e.g. `ECHILD` when there are no more children), the `process_wait` hook raised instead of returning the error as a `Process::Status`, so callers that expect `waitpid` to *report* "no more children" rather than raise would fail.
-
-### v1.19.0
-
-  - Use `io_uring_prep_waitid` for `process_wait` in the `URing` selector (Linux 6.7+), waiting for child exit directly in the ring instead of polling on a `pidfd`. The child is reaped via `rb_process_status_wait` (using `WEXITED | WNOWAIT`) to construct a correct `Process::Status`, and `process_wait(-1, ...)` / `process_wait(0, ...)` are now supported.
-  - Support waiting for any child or a process group (`pid <= 0`) on all selectors. The `EPoll` (`pidfd_open`) and `KQueue` (`EVFILT_PROC`) selectors can only watch a specific process, so these cases now fall back to a blocking wait on a dedicated thread; joining it is fiber-scheduler aware, so the reactor keeps running.
-
 ## Contributing
 
 We welcome contributions to this project.
@@ -82,12 +84,14 @@ bundle exec sus
 
 ### Making Releases
 
-To make a new release:
+To prepare a release pull request:
 
 ``` shell
-bundle exec bake gem:release:patch # or minor or major
+bundle exec bake gem:github:release:patch # or minor or major
 ```
 
+After review and merge, GitHub Actions publishes the release. See [bake-gem-github](https://github.com/socketry/bake-gem-github) for setup and release instructions.
+
 ### Developer Certificate of Origin
 
 In order to protect users of this project, we require all contributors to comply with the [Developer Certificate of Origin](https://developercertificate.org/). This ensures that all contributions are properly licensed and attributed.

data/releases.md

@@ -1,5 +1,14 @@
 # Releases
 
+## v1.22.3
+
+  - Sign releases with the shared Socketry certificate.
+
+## v1.22.2
+
+  - Prevent nested worker-pool waits by running `WorkerPool#call` in a `Fiber.blocking` scope. Blocking operations triggered inside scheduler callbacks, including finalizers, execute synchronously. Cancellation still drains submitted work, and spurious wakeups no longer cancel operations.
+  - Add `IO::Event::Futex` on Linux with Ruby 4.1+, including atomic value operations and blocking and scheduler-aware single and vector waits over shared memory. Futexes retain a counted allocation lock until explicitly closed or finalized; pending waits prevent closing until completion or cancellation has finished.
+
 ## v1.22.1
 
   - Fix an infinite loop in the ready queue flush when a queued fiber is resumed out of band, e.g. by a stale `unblock` racing a timeout, while another fiber re-queues itself on every iteration.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: io-event
 version: !ruby/object:Gem::Version
-  version: 1.22.1
+  version: 1.22.3
 platform: ruby
 authors:
 - Samuel Williams
@@ -28,32 +28,28 @@ bindir: bin
 cert_chain:
 - |
   -----BEGIN CERTIFICATE-----
-  MIIE2DCCA0CgAwIBAgIBATANBgkqhkiG9w0BAQsFADBhMRgwFgYDVQQDDA9zYW11
-  ZWwud2lsbGlhbXMxHTAbBgoJkiaJk/IsZAEZFg1vcmlvbnRyYW5zZmVyMRIwEAYK
-  CZImiZPyLGQBGRYCY28xEjAQBgoJkiaJk/IsZAEZFgJuejAeFw0yMjA4MDYwNDUz
-  MjRaFw0zMjA4MDMwNDUzMjRaMGExGDAWBgNVBAMMD3NhbXVlbC53aWxsaWFtczEd
-  MBsGCgmSJomT8ixkARkWDW9yaW9udHJhbnNmZXIxEjAQBgoJkiaJk/IsZAEZFgJj
-  bzESMBAGCgmSJomT8ixkARkWAm56MIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIB
-  igKCAYEAomvSopQXQ24+9DBB6I6jxRI2auu3VVb4nOjmmHq7XWM4u3HL+pni63X2
-  9qZdoq9xt7H+RPbwL28LDpDNflYQXoOhoVhQ37Pjn9YDjl8/4/9xa9+NUpl9XDIW
-  sGkaOY0eqsQm1pEWkHJr3zn/fxoKPZPfaJOglovdxf7dgsHz67Xgd/ka+Wo1YqoE
-  e5AUKRwUuvaUaumAKgPH+4E4oiLXI4T1Ff5Q7xxv6yXvHuYtlMHhYfgNn8iiW8WN
-  XibYXPNP7NtieSQqwR/xM6IRSoyXKuS+ZNGDPUUGk8RoiV/xvVN4LrVm9upSc0ss
-  RZ6qwOQmXCo/lLcDUxJAgG95cPw//sI00tZan75VgsGzSWAOdjQpFM0l4dxvKwHn
-  tUeT3ZsAgt0JnGqNm2Bkz81kG4A2hSyFZTFA8vZGhp+hz+8Q573tAR89y9YJBdYM
-  zp0FM4zwMNEUwgfRzv1tEVVUEXmoFCyhzonUUw4nE4CFu/sE3ffhjKcXcY//qiSW
-  xm4erY3XAgMBAAGjgZowgZcwCQYDVR0TBAIwADALBgNVHQ8EBAMCBLAwHQYDVR0O
-  BBYEFO9t7XWuFf2SKLmuijgqR4sGDlRsMC4GA1UdEQQnMCWBI3NhbXVlbC53aWxs
-  aWFtc0BvcmlvbnRyYW5zZmVyLmNvLm56MC4GA1UdEgQnMCWBI3NhbXVlbC53aWxs
-  aWFtc0BvcmlvbnRyYW5zZmVyLmNvLm56MA0GCSqGSIb3DQEBCwUAA4IBgQB5sxkE
-  cBsSYwK6fYpM+hA5B5yZY2+L0Z+27jF1pWGgbhPH8/FjjBLVn+VFok3CDpRqwXCl
-  xCO40JEkKdznNy2avOMra6PFiQyOE74kCtv7P+Fdc+FhgqI5lMon6tt9rNeXmnW/
-  c1NaMRdxy999hmRGzUSFjozcCwxpy/LwabxtdXwXgSay4mQ32EDjqR1TixS1+smp
-  8C/NCWgpIfzpHGJsjvmH2wAfKtTTqB9CVKLCWEnCHyCaRVuKkrKjqhYCdmMBqCws
-  JkxfQWC+jBVeG9ZtPhQgZpfhvh+6hMhraUYRQ6XGyvBqEUe+yo6DKIT3MtGE2+CP
-  eX9i9ZWBydWb8/rvmwmX2kkcBbX0hZS1rcR593hGc61JR6lvkGYQ2MYskBveyaxt
-  Q2K9NVun/S785AP05vKkXZEFYxqG6EW012U4oLcFl5MySFajYXRYbuUpH6AY+HP8
-  voD0MPg1DssDLKwXyt1eKD/+Fq0bFWhwVM/1XiAXL7lyYUyOq24KHgQ2Csg=
+  MIIEFDCCAnygAwIBAgIBATANBgkqhkiG9w0BAQsFADAwMREwDwYDVQQKDAhTb2Nr
+  ZXRyeTEbMBkGA1UEAwwSU29ja2V0cnkgUnVieSBHZW1zMB4XDTI2MDkyMTA3NTgx
+  NFoXDTI3MDkyMTA3NTgxNFowMDERMA8GA1UECgwIU29ja2V0cnkxGzAZBgNVBAMM
+  ElNvY2tldHJ5IFJ1YnkgR2VtczCCAaIwDQYJKoZIhvcNAQEBBQADggGPADCCAYoC
+  ggGBAM/QgjVgDzDo/xJEQoFvAzcVFP7msnswkhPJB2UDsbxXCZmers5jV512TM5s
+  NwLHfzJiC4DcI5ax9ZYKM9Q+dS21YYagNqjtg3YPyDqR6phoibEA0VoMuInUQW68
+  i5OkCJzYKGD2pYYVZnuFNqyM2ECUvXh/fBmvPoHbncAHhWPaCBH8mQJ8sRNc6+RV
+  SoZZu1Yo/aW1zQ+SpZwad7s1ZmigfDNHKhJ22KwZHk+/5Zw1QXVfcajjswV0Mm2P
+  irgjKN3fyNVkwlly63EBlR4VydT+g9QtJtqh7ee0ThhI+v4wYovf4dbLNcEBTHu1
+  x1pGbXGx/2fBAST5eVwaXIx1V8VU22AJcBk1H2o5/1F0HfbD2HQjmFOA112KUwBW
+  9TtspZD3g6rCQFX53XvL9h6j2y1ukl7s5AdEzOe/x6r1MO8tSDtgcYoF89wgF/88
+  Q/Eski0FckQ+znfESZcFcpzs2sPDoYW6SNVX4tZcNty85Y6WBHfHKio14x63PeyC
+  CG1gMwIDAQABozkwNzAJBgNVHRMEAjAAMAsGA1UdDwQEAwIEsDAdBgNVHQ4EFgQU
+  SuMc0x24Xshtaa8SQVkBr2Z5WzIwDQYJKoZIhvcNAQELBQADggGBABI62ey5lDWm
+  j8jsTQaNBMBb7LbKS3XkBwyL1UNGEwlicp399rJDeuNgVSHqBCZ/nE4yleNjgW9Y
+  N6DKdxXCvXmFUoHvUINeAvThHxmlEGhSfXl1x55xHEig0rEP4jgdjnYdQI4fqeOM
+  zIDN0F3ruArke4Y62SQgWVN7vspdAA41hBIRl1vsvs0KWG8DIVQ8cmR+TG6zjOmK
+  iUiUZGNPnStV1O1xW83c+Ba4Am0krP6/forxDPhRvTehqkVYvMdPfYcICNb5IM58
+  5vaYvuj5AtfZuZWN0F/0KtSphhNC17rh6h8QmuYdMJ1clvlrkiEaO1UjPVwjgtxC
+  x/ARh5X6q0/YTXl4r7EfSJEeqW7qhgu9EUj3mGIPHYdX0Dqih/NgK20F3GvQtTfB
+  7sse0duKBHXONYVwKAsceUVvqtCfyF608bCilCkbhw3QaInRj+BkRQKJ5Tuj2PZR
+  76a/hwaV2wWn5RtAFBaUQzQdo/xTqJ7IkwaFjOZe/QyvyoRjCK9Rdg==
   -----END CERTIFICATE-----
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
@@ -62,7 +58,7 @@ extensions:
 - ext/extconf.rb
 extra_rdoc_files: []
 files:
-- agent.md
+- context/futex.md
 - context/getting-started.md
 - context/index.yaml
 - design.md
@@ -72,6 +68,8 @@ files:
 - ext/io/event/event.h
 - ext/io/event/fiber.c
 - ext/io/event/fiber.h
+- ext/io/event/futex.c
+- ext/io/event/futex.h
 - ext/io/event/interrupt.c
 - ext/io/event/interrupt.h
 - ext/io/event/list.h
@@ -124,7 +122,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.16
+rubygems_version: 4.0.21
 specification_version: 4
 summary: An event loop.
 test_files: []

data/agent.md

@@ -1,47 +0,0 @@
-# Agent
-
-## Context
-
-This section provides links to documentation from installed packages. It is automatically generated and may be updated by running `bake agent:context:install`.
-
-**Important:** Before performing any code, documentation, or analysis tasks, always read and apply the full content of any relevant documentation referenced in the following sections. These context files contain authoritative standards and best practices for documentation, code style, and project-specific workflows. **Do not proceed with any actions until you have read and incorporated the guidance from relevant context files.**
-
-### agent-context
-
-Install and manage context files from Ruby gems.
-
-#### [Usage Guide](.context/agent-context/usage.md)
-
-`agent-context` is a tool that helps you discover and install contextual information from Ruby gems for AI agents. Gems can provide additional documentation, examples, and guidance in a `context/` ...
-
-### decode
-
-Code analysis for documentation generation.
-
-#### [Getting Started with Decode](.context/decode/getting-started.md)
-
-The Decode gem provides programmatic access to Ruby code structure and metadata. It can parse Ruby files and extract definitions, comments, and documentation pragmas, enabling code analysis, docume...
-
-#### [Documentation Coverage](.context/decode/coverage.md)
-
-This guide explains how to test and monitor documentation coverage in your Ruby projects using the Decode gem's built-in bake tasks.
-
-#### [Ruby Documentation](.context/decode/ruby-documentation.md)
-
-This guide covers documentation practices and pragmas supported by the Decode gem for documenting Ruby code. These pragmas provide structured documentation that can be parsed and used to generate A...
-
-### sus
-
-A fast and scalable test runner.
-
-#### [Using Sus Testing Framework](.context/sus/usage.md)
-
-Sus is a modern Ruby testing framework that provides a clean, BDD-style syntax for writing tests. It's designed to be fast, simple, and expressive.
-
-#### [Mocking](.context/sus/mocking.md)
-
-There are two types of mocking in sus: `receive` and `mock`. The `receive` matcher is a subset of full mocking and is used to set expectations on method calls, while `mock` can be used to replace m...
-
-#### [Shared Test Behaviors and Fixtures](.context/sus/shared.md)
-
-Sus provides shared test contexts which can be used to define common behaviours or tests that can be reused across one or more test files.