io-event 1.16.2 → 1.21.1

data/ext/io/event/worker_pool.c

@@ -306,15 +306,54 @@ static VALUE worker_pool_initialize(int argc, VALUE *argv, VALUE self) {
 	return self;
 }
 
-static VALUE worker_pool_work_begin(VALUE _work) {
+static VALUE worker_pool_work_block(VALUE _work) {
 	struct IO_Event_WorkerPool_Work *work = (void*)_work;
 
-	if (DEBUG) fprintf(stderr, "worker_pool_work_begin:rb_fiber_scheduler_block work=%p\n", work);
+	if (DEBUG) fprintf(stderr, "worker_pool_work_block:rb_fiber_scheduler_block work=%p\n", work);
 	rb_fiber_scheduler_block(work->scheduler, work->blocker, Qnil);
 
 	return Qnil;
 }
 
+static VALUE worker_pool_work_wait(VALUE _work) {
+	struct IO_Event_WorkerPool_Work *work = (void*)_work;
+
+	while (true) {
+		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);
+	}
+
+	return Qtrue;
+}
+
+static VALUE worker_pool_work_ensure(VALUE _work) {
+	struct IO_Event_WorkerPool_Work *work = (void*)_work;
+
+	while (!work->completed) {
+		if (DEBUG) fprintf(stderr, "worker_pool_work_ensure:rb_fiber_scheduler_blocking_operation_cancel\n");
+		rb_fiber_scheduler_blocking_operation_cancel(work->blocking_operation);
+		
+		int state = 0;
+		rb_protect(worker_pool_work_block, _work, &state);
+		if (DEBUG) fprintf(stderr, "-- worker_pool_work_ensure:work completed=%d, state=%d\n", work->completed, state);
+		
+		if (state) {
+			// Ignore errors raised while waiting for cancellation to complete. rb_ensure
+			// will restore and rethrow the original control-flow state after this returns.
+			rb_set_errinfo(Qnil);
+		}
+	}
+
+	return Qnil;
+}
+
 // Ruby method to submit work and wait for completion
 static VALUE worker_pool_call(VALUE self, VALUE _blocking_operation) {
 	struct IO_Event_WorkerPool *pool;
@@ -357,38 +396,10 @@ static VALUE worker_pool_call(VALUE self, VALUE _blocking_operation) {
 	pthread_cond_signal(&pool->work_available);
 	pthread_mutex_unlock(&pool->mutex);
 	
-	// Block the current fiber until work is completed:
-	int state = 0;
-	while (true) {
-		int current_state = 0;
-		rb_protect(worker_pool_work_begin, (VALUE)&work, &current_state);
-		if (DEBUG) fprintf(stderr, "-- worker_pool_call:work completed=%d, current_state=%d, state=%d\n", work.completed, current_state, state);
-		
-		// Store the first exception state:
-		if (!state) {
-			state = current_state;
-		}
-		
-		// If the work is still in the queue, we must wait for a worker to complete it (even if cancelled):
-		if (work.completed) {
-			// The work was completed, we can exit the loop:
-			break;
-		} else {
-			if (DEBUG) fprintf(stderr, "worker_pool_call:rb_fiber_scheduler_blocking_operation_cancel\n");
-			// Ensure the blocking operation is cancelled:
-			rb_fiber_scheduler_blocking_operation_cancel(blocking_operation);
-			
-			// The work was not completed, we need to wait for it to be completed, so we go around the loop again.
-		}
-	}
-	
-	if (DEBUG) fprintf(stderr, "<- worker_pool_call:work completed=%d, state=%d\n", work.completed, state);
-	
-	if (state) {
-		rb_jump_tag(state);
-	} else {
-		return Qtrue;
-	}
+	// 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);
 }
 
 static VALUE worker_pool_allocate(VALUE klass) {

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

@@ -107,6 +107,13 @@ module IO::Event
 				
 				@selector.close
 				@selector = nil
+				
+				@log&.flush
+			end
+			
+			# @returns [Boolean] Whether the wrapped selector is closed.
+			def closed?
+				@selector.nil? || @selector.closed?
 			end
 			
 			# Transfer from the calling fiber to the selector.
@@ -170,15 +177,15 @@ module IO::Event
 			end
 			
 			# Read from the given IO, forwarded to the underlying selector.
-			def io_read(fiber, io, buffer, length, offset = 0)
-				log("Reading from IO #{io.inspect} with buffer #{buffer}; length #{length} offset #{offset}")
-				@selector.io_read(fiber, io, buffer, length, offset)
+			def io_read(fiber, io, buffer, *arguments)
+				log("Reading from IO #{io.inspect} with buffer #{buffer}; arguments #{arguments.inspect}")
+				@selector.io_read(fiber, io, buffer, *arguments)
 			end
 			
 			# Write to the given IO, forwarded to the underlying selector.
-			def io_write(fiber, io, buffer, length, offset = 0)
-				log("Writing to IO #{io.inspect} with buffer #{buffer}; length #{length} offset #{offset}")
-				@selector.io_write(fiber, io, buffer, length, offset)
+			def io_write(fiber, io, buffer, *arguments)
+				log("Writing to IO #{io.inspect} with buffer #{buffer}; arguments #{arguments.inspect}")
+				@selector.io_write(fiber, io, buffer, *arguments)
 			end
 			
 			# Forward the given method to the underlying selector.

data/lib/io/event/interrupt.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2021-2024, by Samuel Williams.
+# Copyright, 2021-2026, by Samuel Williams.
 
 module IO::Event
 	# A thread safe synchronisation primative.
@@ -14,29 +14,34 @@ module IO::Event
 			@selector = selector
 			@input, @output = ::IO.pipe
 			
+			@output.sync = true
+			
 			@fiber = Fiber.new do
 				while true
 					if @selector.io_wait(@fiber, @input, IO::READABLE)
 						@input.read_nonblock(1)
 					end
 				end
+			rescue IOError
+				# This is expected on shutdown.
 			end
 			
 			@fiber.transfer
 		end
 		
-		# Send a sigle byte interrupt.
+		# Send a single byte interrupt.
 		def signal
-			@output.write(".")
-			@output.flush
-		rescue IOError
-			# Ignore.
+			# This must not block or enter blocking operations or raise an exception.
+			# Note that `Scheduler#unblock` defers exceptions, so `IOError` will not be raised by `@output.close` until later.
+			@output.write_nonblock(".", exception: false) rescue nil
 		end
 		
 		def close
+			# In principle, this should cause the fiber to exit:
 			@input.close
+			
+			# This may cause `signal` to raise an exception:
 			@output.close
-			# @fiber.raise(::Interrupt)
 		end
 	end
 	

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

@@ -13,6 +13,7 @@ module IO::Event
 			# Initialize the selector with the given event loop fiber.
 			def initialize(loop)
 				@loop = loop
+				@owner = Process.pid
 				
 				@waiting = Hash.new.compare_by_identity
 				
@@ -52,15 +53,24 @@ module IO::Event
 				@waiting = nil
 			end
 			
+			# @returns [Boolean] Whether the selector is closed or belongs to a different process.
+			def closed?
+				@loop.nil? || @owner != Process.pid
+			end
+			
+			# An optional reference to a fiber which can be cleared before it is resumed.
 			Optional = Struct.new(:fiber) do
+				# Transfer control to the fiber if it is still available.
 				def transfer(*arguments)
 					fiber&.transfer(*arguments)
 				end
 				
+				# @returns [Boolean | Nil] Whether the referenced fiber is still alive.
 				def alive?
 					fiber&.alive?
 				end
 				
+				# Clear the referenced fiber.
 				def nullify
 					self.fiber = nil
 				end
@@ -111,7 +121,9 @@ module IO::Event
 				!@ready.empty?
 			end
 			
+			# A linked list node used to track fibers waiting for IO events.
 			Waiter = Struct.new(:fiber, :events, :tail) do
+				# @returns [Boolean | Nil] Whether the waiting fiber is still alive.
 				def alive?
 					self.fiber&.alive?
 				end
@@ -138,10 +150,12 @@ module IO::Event
 					tail&.dispatch(events, &reactivate)
 				end
 				
+				# Clear the waiting fiber so it will not be resumed.
 				def invalidate
 					self.fiber = nil
 				end
 				
+				# Iterate over each active waiting fiber and its requested events.
 				def each(&block)
 					if fiber = self.fiber
 						yield fiber, self.events
@@ -183,74 +197,112 @@ module IO::Event
 				errno == EAGAIN or errno == EWOULDBLOCK
 			end
 			
-			# Read from the given IO to the buffer.
-			#
-			# @parameter length [Integer] The minimum number of bytes to read.
-			# @parameter offset [Integer] The offset into the buffer to read to.
-			def io_read(fiber, io, buffer, length, offset = 0)
-				# Ensure offset is within the bounds of the buffer to avoid ArgumentError
-				if offset > buffer.size
-					return -Errno::EINVAL::Errno
+			if defined?(IO::Buffer::VERSION) && IO::Buffer::VERSION >= 3
+				# Read at most `length` bytes from the given IO to the buffer in one operation.
+				#
+				# @parameter offset [Integer] The offset into the buffer to read to.
+				# @parameter length [Integer] The maximum number of bytes to read.
+				def io_read(fiber, io, buffer, offset, length)
+					if offset > buffer.size || length > buffer.size - offset
+						return -Errno::EINVAL::Errno
+					elsif length == 0
+						return 0
+					end
+					
+					Selector.nonblock(io) do
+						return Fiber.blocking{buffer.read(io, offset, length)}
+					end
 				end
 				
-				total = 0
-				
-				Selector.nonblock(io) do
-					while true
-						result = Fiber.blocking{buffer.read(io, 0, offset)}
-						
-						if result < 0
-							if length > 0 and again?(result)
-								self.io_wait(fiber, io, IO::READABLE)
+				# Write at most `length` bytes to the given IO from the buffer in one operation.
+				#
+				# @parameter offset [Integer] The offset into the buffer to write from.
+				# @parameter length [Integer] The maximum number of bytes to write.
+				def io_write(fiber, io, buffer, offset, length)
+					if offset > buffer.size || length > buffer.size - offset
+						return -Errno::EINVAL::Errno
+					elsif length == 0
+						return 0
+					end
+					
+					Selector.nonblock(io) do
+						return Fiber.blocking{buffer.write(io, offset, length)}
+					end
+				end
+			else
+				# Read from the given IO to the buffer.
+				#
+				# @parameter length [Integer] The minimum number of bytes to read.
+				# @parameter offset [Integer] The offset into the buffer to read to.
+				def io_read(fiber, io, buffer, length, offset = 0)
+					# Ensure offset is within the bounds of the buffer to avoid `ArgumentError`:
+					if offset > buffer.size
+						return -Errno::EINVAL::Errno
+					elsif offset == buffer.size
+						return 0
+					end
+					
+					total = 0
+					
+					Selector.nonblock(io) do
+						while true
+							result = Fiber.blocking{buffer.read(io, 0, offset)}
+							
+							if result < 0
+								if length > 0 and again?(result)
+									self.io_wait(fiber, io, IO::READABLE)
+								else
+									return result
+								end
+							elsif result == 0
+								break
 							else
-								return result
+								total += result
+								break if total >= length
+								offset += result
 							end
-						elsif result == 0
-							break
-						else
-							total += result
-							break if total >= length
-							offset += result
 						end
 					end
+					
+					return total
 				end
 				
-				return total
-			end
-			
-			# Write to the given IO from the buffer.
-			#
-			# @parameter length [Integer] The minimum number of bytes to write.
-			# @parameter offset [Integer] The offset into the buffer to write from.
-			def io_write(fiber, io, buffer, length, offset = 0)
-				# Ensure offset is within the bounds of the buffer to avoid ArgumentError
-				if offset > buffer.size
-					return -Errno::EINVAL::Errno
-				end
-				
-				total = 0
-				
-				Selector.nonblock(io) do
-					while true
-						result = Fiber.blocking{buffer.write(io, 0, offset)}
-						
-						if result < 0
-							if length > 0 and again?(result)
-								self.io_wait(fiber, io, IO::WRITABLE)
+				# Write to the given IO from the buffer.
+				#
+				# @parameter length [Integer] The minimum number of bytes to write.
+				# @parameter offset [Integer] The offset into the buffer to write from.
+				def io_write(fiber, io, buffer, length, offset = 0)
+					# Ensure offset is within the bounds of the buffer to avoid `ArgumentError`:
+					if offset > buffer.size
+						return -Errno::EINVAL::Errno
+					elsif offset == buffer.size
+						return 0
+					end
+					
+					total = 0
+					
+					Selector.nonblock(io) do
+						while true
+							result = Fiber.blocking{buffer.write(io, 0, offset)}
+							
+							if result < 0
+								if length > 0 and again?(result)
+									self.io_wait(fiber, io, IO::WRITABLE)
+								else
+									return result
+								end
+							elsif result == 0
+								break result
 							else
-								return result
+								total += result
+								break if total >= length
+								offset += result
 							end
-						elsif result == 0
-							break result
-						else
-							total += result
-							break if total >= length
-							offset += result
 						end
 					end
+					
+					return total
 				end
-				
-				return total
 			end
 			
 			# Wait for a process to change state.
@@ -260,9 +312,7 @@ module IO::Event
 			# @parameter flags [Integer] Flags to pass to Process::Status.wait.
 			# @returns [Process::Status] The status of the waited process.
 			def process_wait(fiber, pid, flags)
-				Thread.new do
-					Process::Status.wait(pid, flags)
-				end.value
+				Selector.process_wait(pid, flags)
 			end
 			
 			private def pop_ready

data/lib/io/event/selector.rb

@@ -3,12 +3,17 @@
 # Released under the MIT License.
 # Copyright, 2021-2026, by Samuel Williams.
 
+require_relative "native"
 require_relative "selector/select"
 require_relative "debug/selector"
 
 module IO::Event
 	# @namespace
 	module Selector
+		selectors = [:URing, :EPoll, :KQueue, :Select]
+		BEST = const_get(selectors.find{|name| const_defined?(name)})
+		private_constant :BEST
+		
 		# The default selector implementation, which is chosen based on the environment and available implementations.
 		#
 		# @parameter env [Hash] The environment to read configuration from.
@@ -16,16 +21,8 @@ module IO::Event
 		def self.default(env = ENV)
 			if name = env["IO_EVENT_SELECTOR"]&.to_sym
 				return const_get(name)
-			end
-			
-			if self.const_defined?(:URing)
-				URing
-			elsif self.const_defined?(:EPoll)
-				EPoll
-			elsif self.const_defined?(:KQueue)
-				KQueue
 			else
-				Select
+				BEST
 			end
 		end
 		
@@ -43,5 +40,23 @@ module IO::Event
 			
 			return selector
 		end
+		
+		# Wait for a process to change state, for the cases a selector cannot represent natively (e.g. `pid <= 0`: any child, or a process group). The native selectors integrate process waiting with the event loop using per-process primitives (`pidfd_open`, `EVFILT_PROC`) which can only refer to a single, specific process, and delegate here otherwise.
+		#
+		# The wait is performed on a separate thread, which has no fiber scheduler and therefore blocks. Joining it via `Thread#value` is fiber-scheduler aware, so the calling fiber yields to the event loop and the reactor keeps running other fibers.
+		#
+		# @parameter pid [Integer] The process ID (or process group) to wait for.
+		# @parameter flags [Integer] Flags to pass to `Process::Status.wait`.
+		# @returns [Process::Status] The status of the waited process.
+		def self.process_wait(pid, flags)
+			thread = ::Thread.new do
+				::Process::Status.wait(pid, flags)
+			end
+			
+			thread.value
+		ensure
+			# If the calling fiber was interrupted before the wait completed, don't leave the thread running:
+			thread&.kill
+		end
 	end
 end

data/lib/io/event/timers.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2024-2025, by Samuel Williams.
+# Copyright, 2024-2026, by Samuel Williams.
 
 require_relative "priority_heap"
 

data/lib/io/event/version.rb

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

data/license.md

@@ -19,6 +19,7 @@ Copyright, 2026, by John Hawthorn.
 Copyright, 2026, by Italo Brandão.  
 Copyright, 2026, by Fletcher Dares.  
 Copyright, 2026, by Tavian Barnes.  
+Copyright, 2026, by Sharon Rosner.  
 
 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

@@ -18,51 +18,47 @@ Please see the [project documentation](https://socketry.github.io/io-event/) for
 
 Please see the [project releases](https://socketry.github.io/io-event/releases/index) for all releases.
 
-### v1.16.2
+### v1.21.1
 
-  - Improve timer heap performance by batching scheduled timer insertion, compacting cancelled timers during flush, and avoiding unnecessary heap rebuilds for small incremental inserts.
+  - Fix the `URing` completion free-list empty check so its sole entry can be reused instead of unnecessarily allocating a new completion.
+  - Keep cancelled `URing` completion records allocated until both the operation and cancellation completions have been processed.
 
-### v1.16.1
+### v1.20.0
 
-  - Ensure the pure Ruby `Select` selector returns `false`, not `nil`, when `io_wait` resumes without any ready events.
+  - Add compatibility with Ruby 4.1's fiber scheduler interface version 4. Buffered IO operations now use `(offset, length)`, perform a single transfer of at most `length` bytes, return short transfers directly, and report `-EAGAIN` without waiting. Earlier Ruby versions retain the existing minimum-progress behavior.
 
-### v1.16.0
+### v1.19.5
 
-  - Use `eventfd` for `URing` cross-thread wakeup, and enable `IORING_SETUP_SINGLE_ISSUER`, `IORING_SETUP_DEFER_TASKRUN`, and `IORING_SETUP_TASKRUN_FLAG`. The waking thread now signals via `eventfd` rather than submitting a `NOP` SQE, which unlocks the single-issuer optimisation, defers task work to the application thread, and lets `select()` skip the `io_uring_get_events()` syscall when no task work is pending.
-  - Add support for the `io_close` fiber-scheduler hook (Ruby 4.0+). The `URing` selector performs the close asynchronously via the ring; the `Debug::Selector` and `TestScheduler` wrappers forward to the underlying selector when supported.
-  - Improve `WorkerPool` GC compaction support and add proper write barriers, fixing potential use-after-free under compacting GC.
-  - Keep blocked scheduler fibers alive during GC by registering them as roots in `TestScheduler#block`, preventing premature collection and the resulting use-after-free crash on resume.
-  - Use Ruby's `xmalloc` / `xcalloc` / `xrealloc2` / `xfree` for all internal selector allocations (the per-fiber ready-queue entries in `IO_Event_Selector_ready_push`, and both the backing array and per-element allocations in `IO_Event_Array`). Previously a raw `malloc` paired with a debug-build-only `assert(...)` would silently dereference `NULL` and crash in release builds under memory pressure; the Ruby allocators trigger a GC sweep on pressure and raise `NoMemoryError` / `RangeError` on real failure, so the `-1` return-code paths through `IO_Event_Array_initialize` / `_resize` / `_lookup` and their callers in `epoll.c` / `kqueue.c` / `uring.c` are removed in favour of straight exception propagation.
-  - Correctly handle short `io_uring_submit()` results in the `URing` selector. `io_uring_submit()` returns the number of SQEs actually accepted by the kernel and can be short (SQE prep errors, `ENOMEM`, transient `EAGAIN`); the old accounting reset `pending = 0` on any success and silently lost track of unsubmitted SQEs.
-  - Enable `IORING_SETUP_SUBMIT_ALL` (kernel 5.18+) on the `URing` selector so the kernel keeps processing the rest of an SQE batch past individual errors, reducing the frequency of short submits in practice.
+  - Preserve the original exception or non-local control flow when `IO::Event::WorkerPool` cancellation interrupts a blocked fiber, while still cancelling and draining the in-flight blocking operation before returning control to Ruby.
 
-### v1.15.1
+### v1.19.4
 
-  - Simplify closed-IO handling in the `Select` selector: rely on Ruby 4's `rb_thread_io_close_interrupt` to wake fibers waiting on a descriptor that's been closed, removing a custom error-recovery path that could mis-attribute `IOError` / `Errno::EBADF` to the wrong waiter.
+  - Capture `errno` immediately after `epoll_wait` / `kevent`, preventing stale or subsequently clobbered values from raising a spurious `Errno::*` when a native selector wait is interrupted or skipped.
 
-### v1.15.0
+### v1.19.3
 
-  - Add bounds checks, in the unlikely event of a user providing an invalid offset that exceeds the buffer size. This prevents potential memory corruption and ensures safe operation when using buffered IO methods.
+  - Prevent `URing`, `EPoll`, and `KQueue` from entering a native wait when a signal exception becomes pending during the GVL transition. On Ruby versions without `RB_NOGVL_PENDING_INTR_FAIL`, the fallback now refreshes pending-interrupt state immediately before releasing the GVL while preserving the caller's exception-delivery timing.
 
-### v1.14.4
+### v1.19.2
 
-  - Allow `epoll_pwait2` to be disabled via `--disable-epoll_pwait2`.
+  - 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.14.3
+### v1.19.1
 
-  - Fix several implementation bugs that could cause deadlocks on blocking writes.
+  - 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.14.0
+### v1.19.0
 
-  - [Enhanced `IO::Event::PriorityHeap` with deletion and bulk insertion methods](https://socketry.github.io/io-event/releases/index#enhanced-io::event::priorityheap-with-deletion-and-bulk-insertion-methods)
+  - 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.
 
-### v1.11.2
+### v1.18.0
 
-  - Fix Windows build.
+  - **Fixed**: Avoid entering a blocking native selector wait when an interrupt is already pending for the current thread.
 
-### v1.11.1
+### v1.17.0
 
-  - Fix `read_nonblock` when using the `URing` selector, which was not handling zero-length reads correctly. This allows reading available data without blocking.
+  - Report inherited selector objects as closed after fork, and avoid closing descriptors they no longer own.
 
 ## Contributing
 

data/releases.md

@@ -1,5 +1,55 @@
 # Releases
 
+## v1.21.1
+
+  - Fix the `URing` completion free-list empty check so its sole entry can be reused instead of unnecessarily allocating a new completion.
+  - Keep cancelled `URing` completion records allocated until both the operation and cancellation completions have been processed.
+
+## v1.20.0
+
+  - Add compatibility with Ruby 4.1's fiber scheduler interface version 4. Buffered IO operations now use `(offset, length)`, perform a single transfer of at most `length` bytes, return short transfers directly, and report `-EAGAIN` without waiting. Earlier Ruby versions retain the existing minimum-progress behavior.
+
+## v1.19.5
+
+  - Preserve the original exception or non-local control flow when `IO::Event::WorkerPool` cancellation interrupts a blocked fiber, while still cancelling and draining the in-flight blocking operation before returning control to Ruby.
+
+## v1.19.4
+
+  - Capture `errno` immediately after `epoll_wait` / `kevent`, preventing stale or subsequently clobbered values from raising a spurious `Errno::*` when a native selector wait is interrupted or skipped.
+
+## v1.19.3
+
+  - Prevent `URing`, `EPoll`, and `KQueue` from entering a native wait when a signal exception becomes pending during the GVL transition. On Ruby versions without `RB_NOGVL_PENDING_INTR_FAIL`, the fallback now refreshes pending-interrupt state immediately before releasing the GVL while preserving the caller's exception-delivery timing.
+
+## v1.19.2
+
+  - 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.
+
+## v1.18.0
+
+  - **Fixed**: Avoid entering a blocking native selector wait when an interrupt is already pending for the current thread.
+
+## v1.17.0
+
+  - Report inherited selector objects as closed after fork, and avoid closing descriptors they no longer own.
+
+## v1.16.4
+
+  - Correctly implement `Interrupt#signal` so that it is robust enough to be called by `Scheduler#unblock`.
+
+## v1.16.3
+
+  - Handle `IOError` raised while shutting down the pure Ruby interrupt pipe, so `IO::Event::Interrupt#close` does not leak expected shutdown errors from the interrupt fiber.
+
 ## v1.16.2
 
   - Improve timer heap performance by batching scheduled timer insertion, compacting cancelled timers during flush, and avoiding unnecessary heap rebuilds for small incremental inserts.