async 2.32.0 → 2.39.0

data/lib/async/task.rb

@@ -1,36 +1,52 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2017-2025, by Samuel Williams.
+# Copyright, 2017-2026, by Samuel Williams.
 # Copyright, 2017, by Kent Gruber.
 # Copyright, 2017, by Devin Christensen.
 # Copyright, 2020, by Patrik Wenger.
 # Copyright, 2023, by Math Ieu.
 # Copyright, 2025, by Shigeru Nakajima.
-# Copyright, 2025, by Shopify Inc.
+# Copyright, 2025-2026, by Shopify Inc.
 
 require "fiber"
 require "console"
 
 require_relative "node"
 require_relative "condition"
+require_relative "error"
 require_relative "promise"
 require_relative "stop"
 
 Fiber.attr_accessor :async_task
 
 module Async
-	# Raised if a timeout occurs on a specific Fiber. Handled gracefully by `Task`.
-	# @public Since *Async v1*.
-	class TimeoutError < StandardError
-		# Create a new timeout error.
-		#
-		# @parameter message [String] The error message.
-		def initialize(message = "execution expired")
-			super
-		end
-	end
-	
+	# Represents a sequential unit of work, defined by a block, which is executed concurrently with other tasks. A task can be in one of the following states: `initialized`, `running`, `completed`, `failed`, or `cancelled`.
+	#
+	# ```mermaid
+	# stateDiagram-v2
+	# [*] --> Initialized
+	# Initialized --> Running : Run
+	#
+	# Running --> Completed : Return Value
+	# Running --> Failed : Exception
+	#
+	# Completed --> [*]
+	# Failed --> [*]
+	#
+	# Running --> Cancelled : Cancel
+	# Cancelled --> [*]
+	# Completed --> Cancelled : Cancel
+	# Failed --> Cancelled : Cancel
+	# Initialized --> Cancelled : Cancel
+	# ```
+	#
+	# @example Creating a task that sleeps for 1 second.
+	# 	require "async"
+	# 	Async do |task|
+	# 		sleep(1)
+	# 	end
+	#
 	# @public Since *Async v1*.
 	class Task < Node
 		# Raised when a child task is created within a task that has finished execution.
@@ -61,8 +77,6 @@ module Async
 		# @parameter reactor [Reactor] the reactor this task will run within.
 		# @parameter parent [Task] the parent task.
 		def initialize(parent = Task.current?, finished: nil, **options, &block)
-			super(parent, **options)
-			
 			# These instance variables are critical to the state of the task.
 			# In the initialized state, the @block should be set, but the @fiber should be nil.
 			# In the running state, the @fiber should be set, and @block should be nil.
@@ -84,7 +98,10 @@ module Async
 				warn("finished: argument with non-false value is deprecated and will be removed.", uplevel: 1, category: :deprecated) if $VERBOSE
 			end
 			
-			@defer_stop = nil
+			@defer_cancel = nil
+			
+			# Call this after all state is initialized, as it may call `add_child` which will set the parent and make it visible to the scheduler.
+			super(parent, **options)
 		end
 		
 		# @returns [Scheduler] The scheduler for this task.
@@ -166,8 +183,8 @@ module Async
 			@promise.failed?
 		end
 		
-		# @returns [Boolean] Whether the task has been stopped.
-		def stopped?
+		# @returns [Boolean] Whether the task has been cancelled.
+		def cancelled?
 			@promise.cancelled?
 		end
 		
@@ -181,11 +198,11 @@ module Async
 			self.completed?
 		end
 		
-		# @attribute [Symbol] The status of the execution of the task, one of `:initialized`, `:running`, `:complete`, `:stopped` or `:failed`.
+		# @attribute [Symbol] The status of the execution of the task, one of `:initialized`, `:running`, `:complete`, `:cancelled` or `:failed`.
 		def status
 			case @promise.resolved
 			when :cancelled
-				:stopped
+				:cancelled
 			when :failed
 				:failed
 			when :completed
@@ -243,29 +260,58 @@ module Async
 			return task
 		end
 		
-		# Retrieve the current result of the task. Will cause the caller to wait until result is available. If the task resulted in an unhandled error (derived from `StandardError`), this will be raised. If the task was stopped, this will return `nil`.
+		# Retrieve the current result of the task. Will cause the caller to wait until result is available. If the task resulted in an unhandled error (derived from `StandardError`), this will be raised. If the task was cancelled, this will return `nil`.
 		#
 		# Conceptually speaking, waiting on a task should return a result, and if it throws an exception, this is certainly an exceptional case that should represent a failure in your program, not an expected outcome. In other words, you should not design your programs to expect exceptions from `#wait` as a normal flow control, and prefer to catch known exceptions within the task itself and return a result that captures the intention of the failure, e.g. a `TimeoutError` might simply return `nil` or `false` to indicate that the operation did not generate a valid result (as a timeout was an expected outcome of the internal operation in this case).
 		#
+		# @parameter timeout [Numeric] The maximum number of seconds to wait for the result before raising a `TimeoutError`, if specified.
 		# @raises [RuntimeError] If the task's fiber is the current fiber.
 		# @returns [Object] The final expression/result of the task's block.
 		# @asynchronous This method is thread-safe.
-		def wait
+		def wait(...)
 			raise "Cannot wait on own fiber!" if Fiber.current.equal?(@fiber)
 			
-			# Wait for the task to complete - Promise handles all the complexity:
-			begin
-				@promise.wait
-			rescue Promise::Cancel
-				# For backward compatibility, stopped tasks return nil
-				return nil
+			# Wait for the task to complete:
+			@promise.wait(...)
+		end
+		
+		# For compatibility with `Thread#join` and similar interfaces.
+		alias join wait
+		
+		# Wait on all non-transient children to complete, recursively, then wait on the task itself, if it is not the current task.
+		#
+		# If any child task fails with an exception, that exception will be raised immediately, and remaining children may not be waited on.
+		#
+		# @example Waiting on all children.
+		# 	Async do |task|
+		# 		child = task.async do
+		# 			sleep(0.01)
+		# 		end
+		# 		task.wait_all # Will wait on the child task.
+		# 	end
+		#
+		# @raises [StandardError] If any child task failed with an exception, that exception will be raised.
+		# @returns [Object | Nil] The final expression/result of the task's block, or nil if called from within the task.
+		# @asynchronous This method is thread-safe.
+		def wait_all
+			@children&.each do |child|
+				# Skip transient tasks
+				next if child.transient?
+				
+				child.wait_all
+			end
+			
+			# Only wait on the task if we're not waiting on ourselves:
+			unless self.current?
+				return self.wait
 			end
 		end
 		
 		# Access the result of the task without waiting. May be nil if the task is not completed. Does not raise exceptions.
 		def result
 			value = @promise.value
-			# For backward compatibility, return nil for stopped tasks
+			
+			# For backward compatibility, return nil for cancelled tasks:
 			if @promise.cancelled?
 				nil
 			else
@@ -273,103 +319,115 @@ module Async
 			end
 		end
 		
-		# Stop the task and all of its children.
+		# Cancel the task and all of its children.
 		#
-		# If `later` is false, it means that `stop` has been invoked directly. When `later` is true, it means that `stop` is invoked by `stop_children` or some other indirect mechanism. In that case, if we encounter the "current" fiber, we can't stop it right away, as it's currently performing `#stop`. Stopping it immediately would interrupt the current stop traversal, so we need to schedule the stop to occur later.
+		# If `later` is false, it means that `cancel` has been invoked directly. When `later` is true, it means that `cancel` is invoked by `stop_children` or some other indirect mechanism. In that case, if we encounter the "current" fiber, we can't cancel it right away, as it's currently performing `#cancel`. Cancelling it immediately would interrupt the current cancel traversal, so we need to schedule the cancel to occur later.
 		#
-		# @parameter later [Boolean] Whether to stop the task later, or immediately.
-		# @parameter cause [Exception] The cause of the stop operation.
-		def stop(later = false, cause: $!)
+		# @parameter later [Boolean] Whether to cancel the task later, or immediately.
+		# @parameter cause [Exception] The cause of the cancel operation.
+		def cancel(later = false, cause: $!)
 			# If no cause is given, we generate one from the current call stack:
 			unless cause
-				cause = Stop::Cause.for("Stopping task!")
+				cause = Cancel::Cause.for("Cancelling task!")
 			end
 			
-			if self.stopped?
-				# If the task is already stopped, a `stop` state transition re-enters the same state which is a no-op. However, we will also attempt to stop any running children too. This can happen if the children did not stop correctly the first time around. Doing this should probably be considered a bug, but it's better to be safe than sorry.
-				return stopped!
+			if self.cancelled?
+				# If the task is already cancelled, a `cancel` state transition re-enters the same state which is a no-op. However, we will also attempt to cancel any running children too. This can happen if the children did not cancel correctly the first time around. Doing this should probably be considered a bug, but it's better to be safe than sorry.
+				return cancelled!
 			end
 			
-			# If the fiber is alive, we need to stop it:
+			# If the fiber is alive, we need to cancel it:
 			if @fiber&.alive?
 				# As the task is now exiting, we want to ensure the event loop continues to execute until the task finishes.
 				self.transient = false
 				
-				# If we are deferring stop...
-				if @defer_stop == false
-					# Don't stop now... but update the state so we know we need to stop later.
-					@defer_stop = cause
+				# If we are deferring cancel...
+				if @defer_cancel == false
+					# Don't cancel now... but update the state so we know we need to cancel later.
+					@defer_cancel = cause
 					return false
 				end
 				
 				if self.current?
-					# If the fiber is current, and later is `true`, we need to schedule the fiber to be stopped later, as it's currently invoking `stop`:
+					# If the fiber is current, and later is `true`, we need to schedule the fiber to be cancelled later, as it's currently invoking `cancel`:
 					if later
-						# If the fiber is the current fiber and we want to stop it later, schedule it:
-						Fiber.scheduler.push(Stop::Later.new(self, cause))
+						# If the fiber is the current fiber and we want to cancel it later, schedule it:
+						Fiber.scheduler.push(Cancel::Later.new(self, cause))
 					else
 						# Otherwise, raise the exception directly:
-						raise Stop, "Stopping current task!", cause: cause
+						raise Cancel, "Cancelling current task!", cause: cause
 					end
 				else
 					# If the fiber is not curent, we can raise the exception directly:
 					begin
-						# There is a chance that this will stop the fiber that originally called stop. If that happens, the exception handling in `#stopped` will rescue the exception and re-raise it later.
-						Fiber.scheduler.raise(@fiber, Stop, cause: cause)
+						# There is a chance that this will cancel the fiber that originally called cancel. If that happens, the exception handling in `#cancelled` will rescue the exception and re-raise it later.
+						Fiber.scheduler.raise(@fiber, Cancel, cause: cause)
 					rescue FiberError
-						# In some cases, this can cause a FiberError (it might be resumed already), so we schedule it to be stopped later:
-						Fiber.scheduler.push(Stop::Later.new(self, cause))
+						# In some cases, this can cause a FiberError (it might be resumed already), so we schedule it to be cancelled later:
+						Fiber.scheduler.push(Cancel::Later.new(self, cause))
 					end
 				end
 			else
-				# We are not running, but children might be, so transition directly into stopped state:
-				stop!
+				# We are not running, but children might be, so transition directly into cancelled state:
+				cancel!
 			end
 		end
 		
-		# Defer the handling of stop. During the execution of the given block, if a stop is requested, it will be deferred until the block exits. This is useful for ensuring graceful shutdown of servers and other long-running tasks. You should wrap the response handling code in a defer_stop block to ensure that the task is stopped when the response is complete but not before.
+		# Defer the handling of cancel. During the execution of the given block, if a cancel is requested, it will be deferred until the block exits. This is useful for ensuring graceful shutdown of servers and other long-running tasks. You should wrap the response handling code in a defer_cancel block to ensure that the task is cancelled when the response is complete but not before.
 		#
-		# You can nest calls to defer_stop, but the stop will only be deferred until the outermost block exits.
+		# You can nest calls to defer_cancel, but the cancel will only be deferred until the outermost block exits.
 		#
-		# If stop is invoked a second time, it will be immediately executed.
+		# If cancel is invoked a second time, it will be immediately executed.
 		#
 		# @yields {} The block of code to execute.
 		# @public Since *Async v1*.
-		def defer_stop
-			# Tri-state variable for controlling stop:
-			# - nil: defer_stop has not been called.
-			# - false: defer_stop has been called and we are not stopping.
-			# - true: defer_stop has been called and we will stop when exiting the block.
-			if @defer_stop.nil?
+		def defer_cancel
+			# Tri-state variable for controlling cancel:
+			# - nil: defer_cancel has not been called.
+			# - false: defer_cancel has been called and we are not cancelling.
+			# - true: defer_cancel has been called and we will cancel when exiting the block.
+			if @defer_cancel.nil?
 				begin
-					# If we are not deferring stop already, we can defer it now:
-					@defer_stop = false
+					# If we are not deferring cancel already, we can defer it now:
+					@defer_cancel = false
 					
 					yield
-				rescue Stop
-					# If we are exiting due to a stop, we shouldn't try to invoke stop again:
-					@defer_stop = nil
+				rescue Cancel
+					# If we are exiting due to a cancel, we shouldn't try to invoke cancel again:
+					@defer_cancel = nil
 					raise
 				ensure
-					defer_stop = @defer_stop
+					defer_cancel = @defer_cancel
 					
 					# We need to ensure the state is reset before we exit the block:
-					@defer_stop = nil
+					@defer_cancel = nil
 					
-					# If we were asked to stop, we should do so now:
-					if defer_stop
-						raise Stop, "Stopping current task (was deferred)!", cause: defer_stop
+					# If we were asked to cancel, we should do so now:
+					if defer_cancel
+						raise Cancel, "Cancelling current task (was deferred)!", cause: defer_cancel
 					end
 				end
 			else
-				# If we are deferring stop already, entering it again is a no-op.
+				# If we are deferring cancel already, entering it again is a no-op.
 				yield
 			end
 		end
 		
-		# @returns [Boolean] Whether stop has been deferred.
+		# Backward compatibility alias for {#defer_cancel}.
+		# @deprecated Use {#defer_cancel} instead.
+		def defer_stop(&block)
+			defer_cancel(&block)
+		end
+		
+		# @returns [Boolean] Whether cancel has been deferred.
+		def cancel_deferred?
+			!!@defer_cancel
+		end
+		
+		# Backward compatibility alias for {#cancel_deferred?}.
+		# @deprecated Use {#cancel_deferred?} instead.
 		def stop_deferred?
-			!!@defer_stop
+			cancel_deferred?
 		end
 		
 		# Lookup the {Task} for the current fiber. Raise `RuntimeError` if none is available.
@@ -398,6 +456,9 @@ module Async
 		
 		# Finish the current task, moving any children to the parent.
 		def finish!
+			# Break the cycle:
+			@fiber&.async_task = nil
+			
 			# Don't hold references to the fiber or block after the task has finished:
 			@fiber = nil
 			@block = nil # If some how we went directly from initialized to finished.
@@ -409,49 +470,57 @@ module Async
 		# State transition into the completed state.
 		def completed!(result)
 			# Resolve the promise with the result:
-			@promise&.resolve(result)
+			@promise.resolve(result)
 		end
 		
 		# State transition into the failed state.
 		def failed!(exception = false)
 			# Reject the promise with the exception:
-			@promise&.reject(exception)
+			@promise.reject(exception)
 		end
 		
-		def stopped!
-			# Console.info(self, status:) {"Task #{self} was stopped with #{@children&.size.inspect} children!"}
+		def cancelled!
+			# Console.info(self, status:) {"Task #{self} was cancelled with #{@children&.size.inspect} children!"}
 			
-			# Cancel the promise:
-			@promise&.cancel
+			# Cancel the promise, specify nil here so that no exception is raised when waiting on the promise:
+			@promise.cancel(nil)
 			
-			stopped = false
+			cancelled = false
 			
 			begin
 				# We are not running, but children might be so we should stop them:
 				stop_children(true)
-			rescue Stop
-				stopped = true
-				# If we are stopping children, and one of them tries to stop the current task, we should ignore it. We will be stopped later.
+			rescue Cancel
+				cancelled = true
+				# If we are cancelling children, and one of them tries to cancel the current task, we should ignore it. We will be cancelled later.
 				retry
 			end
 			
-			if stopped
-				raise Stop, "Stopping current task!"
+			if cancelled
+				raise Cancel, "Cancelling current task!"
 			end
 		end
 		
-		def stop!
-			stopped!
+		def stopped!
+			cancelled!
+		end
+		
+		def cancel!
+			cancelled!
 			
 			finish!
 		end
 		
+		def stop!
+			cancel!
+		end
+		
 		def schedule(&block)
 			@fiber = Fiber.new(annotation: self.annotation) do
 				begin
 					completed!(yield)
-				rescue Stop
-					stopped!
+				rescue Cancel
+					cancelled!
 				rescue StandardError => error
 					failed!(error)
 				rescue Exception => exception

data/lib/async/version.rb

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2017-2025, by Samuel Williams.
+# Copyright, 2017-2026, by Samuel Williams.
 
+# @namespace
 module Async
-	VERSION = "2.32.0"
+	VERSION = "2.39.0"
 end

data/lib/async.rb

@@ -1,15 +1,13 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2017-2024, by Samuel Williams.
+# Copyright, 2017-2026, by Samuel Williams.
 # Copyright, 2020, by Salim Semaoune.
 
 require_relative "async/version"
 require_relative "async/reactor"
+require_relative "async/loop"
 
 require_relative "kernel/async"
 require_relative "kernel/sync"
-
-# Asynchronous programming framework.
-module Async
-end
+require_relative "kernel/barrier"

data/lib/kernel/barrier.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2025, by Samuel Williams.
+
+require_relative "sync"
+require_relative "../async/barrier"
+require_relative "../async/idler"
+
+module Kernel
+	# Create a barrier, yield it to the block, and then wait for all tasks to complete.
+	#
+	# If no scheduler is running, one will be created automatically for the duration of the block.
+	#
+	# By default, the barrier uses an `Async::Idler` to manage load, but this can be overridden by providing a different parent or `nil` to disable load management.
+	#
+	# @parameter parent [Task | Semaphore | Nil] The parent for holding any children tasks.
+	# @parameter **options [Hash] Additional options passed to {Kernel::Sync}.
+	# @public Since *Async v2.34*.
+	def Barrier(parent: Async::Idler.new, **options)
+		Sync(**options) do |task|
+			barrier = ::Async::Barrier.new(parent: parent)
+			
+			yield barrier
+			
+			barrier.wait
+		ensure
+			barrier&.stop
+		end
+	end
+end

data/lib/kernel/sync.rb

@@ -20,7 +20,7 @@ module Kernel
 	def Sync(annotation: nil, &block)
 		if task = ::Async::Task.current?
 			if annotation
-				task.annotate(annotation) {yield task}
+				task.annotate(annotation){yield task}
 			else
 				yield task
 			end

data/lib/traces/provider/async/barrier.rb

@@ -12,6 +12,6 @@ Traces::Provider(Async::Barrier) do
 			"size" => self.size
 		}
 		
-		Traces.trace("async.barrier.wait", attributes: attributes) {super}
+		Traces.trace("async.barrier.wait", attributes: attributes){super}
 	end
 end

data/license.md

@@ -1,6 +1,6 @@
 # MIT License
 
-Copyright, 2017-2025, by Samuel Williams.  
+Copyright, 2017-2026, by Samuel Williams.  
 Copyright, 2017, by Kent Gruber.  
 Copyright, 2017, by Devin Christensen.  
 Copyright, 2018, by Sokolov Yura.  
@@ -31,9 +31,11 @@ Copyright, 2025, by Jahfer Husain.
 Copyright, 2025, by Mark Montroy.  
 Copyright, 2025, by Shigeru Nakajima.  
 Copyright, 2025, by Alan Wu.  
-Copyright, 2025, by Shopify Inc.  
+Copyright, 2025-2026, by Shopify Inc.  
 Copyright, 2025, by Josh Teeter.  
 Copyright, 2025, by Jatin Goyal.  
+Copyright, 2025, by Yuhi Sato.  
+Copyright, 2026, by Tavian Barnes.  
 
 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

@@ -35,63 +35,57 @@ Please see the [project documentation](https://socketry.github.io/async/) for mo
 
 Please see the [project releases](https://socketry.github.io/async/releases/index) for all releases.
 
-### v2.32.0
+### v2.39.0
 
-  - Introduce `Queue#waiting_count` and `PriorityQueue#waiting_count`. Generally for statistics/testing purposes only.
+  - `Async::Barrier#wait` now returns the number of tasks that were waited for, or `nil` if there were no tasks to wait for. This provides better feedback about the operation, and allows you to know how many tasks were involved in the wait.
 
-### v2.31.0
+### v2.38.1
 
-  - Introduce `Async::Deadline` for precise timeout management in compound operations.
+  - Fix `Barrier#async` when `parent.async` yields before the child block executes. Previously, `Barrier#wait` could return early and miss tracking the task entirely, because the task had not yet appended itself to the barrier's task list.
 
-### v2.30.0
+### v2.38.0
 
-  - Add timeout support to `Async::Queue#dequeue` and `Async::Queue#pop` methods.
-  - Add timeout support to `Async::PriorityQueue#dequeue` and `Async::PriorityQueue#pop` methods.
-  - Add `closed?` method to `Async::PriorityQueue` for full queue interface compatibility.
-  - Support non-blocking operations using `timeout: 0` parameter.
+  - Rename `Task#stop` to `Task#cancel` for better clarity and consistency with common concurrency terminology. The old `stop` method is still available as an alias for backward compatibility, but it is recommended to use `cancel` going forward.
+  - Forward arguments from `Task#wait` -\> `Promise#wait`, so `task.wait(timeout: N)` is supported.
 
-### v2.29.0
+### v2.37.0
 
-This release introduces thread-safety as a core concept of Async. Many core classes now have thread-safe guarantees, allowing them to be used safely across multiple threads.
+  - Introduce `Async::Loop` for robust, time-aligned loops.
+  - Add support for `Async::Promise#wait(timeout: N)`.
 
-  - Thread-safe `Async::Condition` and `Async::Notification`, implemented using `Thread::Queue`.
-  - Thread-safe `Async::Queue` and `Async::LimitedQueue`, implemented using `Thread::Queue` and `Thread::LimitedQueue` respectively.
-  - `Async::Variable` is deprecated in favor of `Async::Promise`.
-  - [Introduce `Async::Promise`](https://socketry.github.io/async/releases/index#introduce-async::promise)
-  - [Introduce `Async::PriorityQueue`](https://socketry.github.io/async/releases/index#introduce-async::priorityqueue)
+### v2.36.0
 
-### v2.28.1
+  - Introduce `Task#wait_all` which recursively waits for all children and self, excepting the current task.
+  - Introduce `Task#join` as an alias for `Task#wait` for compatibility with `Thread#join` and similar interfaces.
 
-  - Fix race condition between `Async::Barrier#stop` and finish signalling.
+### v2.35.3
 
-### v2.28.0
+  - `Async::Clock` now implements `#as_json` and `#to_json` for nicer log formatting.
 
-  - Use `Traces.current_context` and `Traces.with_context` for better integration with OpenTelemetry.
+### v2.35.2
 
-### v2.27.4
+  - Improved handling of `Process.fork` on Ruby 4+.
+  - Improve `@promise` state handling in `Task#initialize`, preventing incomplete instances being visible to the scheduler.
 
-  - Suppress excessive warning in `Async::Scheduler#async`.
+### v2.35.1
 
-### v2.27.3
+  - Fix incorrect handling of spurious wakeups in `Async::Promise#wait`, which could lead to premature (incorrect) resolution of the promise.
 
-  - Ensure trace attributes are strings, fixes integration with OpenTelemetry.
+### v2.35.0
 
-### v2.27.2
+  - `Process.fork` is now properly handled by the Async fiber scheduler, ensuring that the scheduler state is correctly reset in the child process after a fork. This prevents issues where the child process inherits the scheduler state from the parent, which could lead to unexpected behavior.
 
-  - Fix `context/index.yaml` schema.
+### v2.34.0
 
-### v2.27.1
-
-  - Updated documentation and agent context.
+  - [`Kernel::Barrier` Convenience Interface](https://socketry.github.io/async/releases/index#kernel::barrier-convenience-interface)
 
 ## See Also
 
   - [async-http](https://github.com/socketry/async-http) — Asynchronous HTTP client/server.
+  - [falcon](https://github.com/socketry/falcon) — A rack compatible server built on top of `async-http`.
   - [async-websocket](https://github.com/socketry/async-websocket) — Asynchronous client and server websockets.
   - [async-dns](https://github.com/socketry/async-dns) — Asynchronous DNS resolver and server.
-  - [falcon](https://github.com/socketry/falcon) — A rack compatible server built on top of `async-http`.
-  - [rubydns](https://github.com/ioquatix/rubydns) — An easy to use Ruby DNS server.
-  - [slack-ruby-bot](https://github.com/slack-ruby/slack-ruby-bot) — A client for making slack bots.
+  - [toolbox](https://github.com/socketry/toolbox) — GDB & LLDB extensions for debugging Ruby applications with Fibers.
 
 ## Contributing