farce 0.4.1 → 0.5.0

data/lib/farce/engine/shared/queue.rb

@@ -9,17 +9,56 @@ module Farce
       include Freeze::Unfreezable
 
       NIL_VALUE = Object.new.freeze
-      attr_reader :capacity
 
       def initialize(capacity: 1024, track_age: false)
         @queue     = capacity ? Thread::SizedQueue.new(capacity) : Thread::Queue.new
-        @capacity  = capacity
         @signal    = Signal.new
         @tracking  = track_age ? { lock: Mutex.new, timestamps: [], generation: 0 } : nil
-        @lifecycle = { lock: Mutex.new, hard_closed: false }
+        @lifecycle = { lock: Mutex.new, hard_closed: false, token: nil, generation: -1 }
         Freeze.publish(self)
       end
 
+      def capacity = @queue.is_a?(Thread::SizedQueue) ? @queue.max : nil
+
+      def capacity=(value)
+        value = Integer(value) unless value.nil?
+        raise ArgumentError, "capacity must be positive or nil" if value && !value.positive?
+        if value.nil? != capacity.nil?
+          raise ArgumentError, "cannot switch between bounded and unbounded queues on this Ruby engine"
+        end
+        @queue.max = value if value
+        broadcast
+        value
+      end
+
+      def interrupt(token, generation)
+        @lifecycle[:lock].synchronize do
+          return self if generation <= @lifecycle[:generation]
+          @lifecycle[:token] = token
+          @lifecycle[:generation] = generation
+        end
+        broadcast
+        self
+      end
+
+      def pop_interruptible(token, timeout)
+        timeout_at = timeout_at(timeout)
+        loop do
+          return false unless @lifecycle[:lock].synchronize { @lifecycle[:token].equal?(token) }
+          begin
+            result = tracked_pop
+            raise ThreadError if nil.equal?(result) && @queue.closed?
+            broadcast
+            return NIL_VALUE.equal?(result) ? nil : result
+          rescue ThreadError
+            ready = wait(remaining_timeout(timeout_at)) do
+              !@lifecycle[:lock].synchronize { @lifecycle[:token].equal?(token) } || size.positive?
+            end
+            return block_given? ? yield : nil unless ready
+          end
+        end
+      end
+
       def pop(timeout: nil)
         timeout_at = timeout_at(timeout)
         # Observing an empty queue is sufficient for a nonblocking miss. Avoid
@@ -223,8 +262,7 @@ module Farce
       def remaining_timeout(timeout_at)
         return unless timeout_at
         return 0 if timeout_at.zero?
-        timeout = timeout_at - Clock.now
-        timeout.positive? ? timeout : 0
+        Clock.remaining(timeout_at)
       end
 
       def broadcast = @signal.broadcast

data/lib/farce/engine/shared/ractor_selector.rb

@@ -61,7 +61,7 @@ module Farce
             result = port.select_receive
             return result if result
           end
-          remaining = deadline - Clock.now if deadline
+          remaining = Clock.remaining(deadline)
           return if remaining && !remaining.positive?
           return unless ReservationWaiting.wait(wakeup, generation, deadline)
         end

data/lib/farce/engine/shared/strict_map.rb

@@ -67,6 +67,11 @@ module Farce
         super(check_key(key), **) { |value| check_value(yield(value)) }
       end
 
+      def modify(key, **)
+        raise LocalJumpError, "no block given" unless block_given?
+        super(check_key(key), **) { |present, value| check_value(yield(present, value)) }
+      end
+
       def upsert(key, initial, **)
         raise LocalJumpError, "no block given" unless block_given?
         super(check_key(key), check_value(initial), **) { |value| check_value(yield(value)) }

data/lib/farce/engine/shared/unshared_atom.rb

@@ -129,7 +129,7 @@ module Farce
 
         loop do
           current, version = @mutex.synchronize { [@value, @version] }
-          return current unless values_equal?(current, expected)
+          return current if Internal.value_changed?(current, expected, compare_by_identity?)
 
           result = @mutex.synchronize do
             next unless @version == version

data/lib/farce/engine/shared/unshared_vector.rb

@@ -274,12 +274,12 @@ module Farce
         finish_update if completed
       end
 
-      def wait_until_changed(index, expected, timeout: nil)
-        wait_for_value(convert_index(index), expected, timeout_deadline(timeout), non_nil: false)
+      def wait_until_changed(index, expected, timeout: nil, &fallback)
+        wait_for_value(convert_index(index), expected, timeout_deadline(timeout), fallback, non_nil: false)
       end
 
       def wait_until_non_nil(index, timeout: nil)
-        wait_for_value(convert_index(index), nil, timeout_deadline(timeout), non_nil: true)
+        wait_for_value(convert_index(index), nil, timeout_deadline(timeout), nil, non_nil: true)
       end
 
       def compare_by_identity? = @compare_by_identity
@@ -341,20 +341,21 @@ module Farce
         raise FrozenError.new("can't modify frozen #{self.class}", receiver: self)
       end
 
-      def wait_for_value(index, expected, deadline, non_nil:)
+      def wait_for_value(index, expected, deadline, fallback, non_nil:)
         while true
           generation = @signal.generation
           current    = @mutex.synchronize { @values[index] }
-          ready      = non_nil ? !current.nil? : !values_equal?(current, expected)
+          ready      = non_nil ? !current.nil? :
+            Internal.value_changed?(current, expected, compare_by_identity?)
           return current if ready
-          return unless wait_for_signal(generation, deadline)
+          return fallback&.call unless wait_for_signal(generation, deadline)
         end
       end
 
       def wait_for_signal(generation, deadline)
         return @signal.wait(generation) unless deadline
 
-        remaining = deadline - Clock.now
+        remaining = Clock.remaining(deadline)
         return false unless remaining.positive?
         !@signal.wait(generation, timeout: remaining).nil?
       end

data/lib/farce/engine/shared/unshared_weak_map.rb

@@ -145,10 +145,11 @@ module Farce
       # Yield presence and value under the entry reservation.
       # MAP_KEEP and MAP_DELETE are control results. Other results replace the value.
       # Return whether a change committed.
-      def modify(key) # rubocop:disable Naming/PredicateMethod
+      def modify(key, timeout: nil)
         raise LocalJumpError, "no block given" unless block_given?
         check_frozen!
-        _, result = with_entry(key, nil, create: true, mutating: true) do |present, current, entry, index|
+        deadline = timeout_deadline(timeout)
+        completed, result = with_entry(key, deadline, create: true, mutating: true) do |present, current, entry, index|
           value = yield(present, current)
           check_frozen!
           if MAP_KEEP.equal?(value)
@@ -161,7 +162,7 @@ module Farce
             entry.store(value)
           end
         end
-        !!result
+        completed && !!result
       end
 
       def wait_until_changed(key, expected, timeout: nil, &fallback)
@@ -352,7 +353,7 @@ module Farce
           return fallback&.call if timed_out == :timed_out
 
           unless entry
-            return nil unless values_equal?(nil, expected)
+            return nil if Internal.value_changed?(nil, expected, compare_values_by_identity?)
             return fallback&.call unless signal_changed?(@index.change_signal, observed, deadline)
             next
           end
@@ -373,13 +374,14 @@ module Farce
           # lookup object. Otherwise GC could orphan the entry's change signal.
           key     = stored_key
           current = nil unless present
-          return current if non_nil ? !current.nil? : !values_equal?(current, expected)
+          return current if non_nil ? !current.nil? :
+            Internal.value_changed?(current, expected, compare_values_by_identity?)
           return fallback&.call unless entry.wait_for_change?(changed, deadline)
         end
       end
 
       def signal_changed?(signal, observed, deadline)
-        timeout = deadline - Clock.now if deadline
+        timeout = Clock.remaining(deadline)
         return false if timeout && !timeout.positive?
 
         timed_out = Object.new

data/lib/farce/engine/shared/weak_atom/base.rb

@@ -146,7 +146,7 @@ module Farce
       def with_value(timeout)
         deadline = timeout_deadline(timeout)
         result = TIMED_OUT
-        @lock.update(timeout: remaining_timeout(deadline)) do
+        @lock.update(timeout: Clock.remaining(deadline)) do
           result = yield
           nil
         end
@@ -158,11 +158,12 @@ module Farce
         loop do
           generation = @changes.value
           current    = read_value
-          return current if non_nil ? !current.nil? : !values_equal?(current, expected)
+          return current if non_nil ? !current.nil? :
+            Internal.value_changed?(current, expected, compare_by_identity?)
           # Detect recursive waits without waiting for another owner's update.
           @lock.get(timeout: 0)
-          return fallback&.call if remaining_timeout(deadline)&.zero?
-          @changes.wait_until_changed(generation, timeout: remaining_timeout(deadline))
+          return fallback&.call if Clock.remaining(deadline)&.zero?
+          @changes.wait_until_changed(generation, timeout: Clock.remaining(deadline))
         end
       end
 
@@ -177,12 +178,6 @@ module Farce
         raise ArgumentError, "timeout must be finite and non-negative" unless timeout.finite? && !timeout.negative?
         Clock.now + timeout
       end
-
-      def remaining_timeout(deadline)
-        return unless deadline
-        remaining = deadline - Clock.now
-        remaining.negative? ? 0 : remaining
-      end
     end
     private_constant :WeakAtomBase
   end

data/lib/farce/engine/shared/weak_map/cell.rb

@@ -61,7 +61,7 @@ module Farce
       end
 
       def wait_for_change?(observed, deadline)
-        timeout = deadline - Clock.now if deadline
+        timeout = Clock.remaining(deadline)
         return false if timeout && !timeout.positive?
         !!@changes.wait(observed, timeout:) { false }
       end

data/lib/farce/engine/truffleruby/map.rb

@@ -28,7 +28,8 @@ module Farce
         end
 
         def eql?(other)
-          result = other.is_a?(Key) && value.eql?(other.value)
+          result = other.is_a?(Key) &&
+            (BASIC_OBJECT_EQUAL_METHOD.bind_call(value, other.value) || value.eql?(other.value))
           owner = mutation_owner || (other.mutation_owner if other.is_a?(Key))
           Internal::Freeze.check(owner) if owner
           result
@@ -214,11 +215,11 @@ module Farce
       # Yield presence and value under the key reservation.
       # MAP_KEEP and MAP_DELETE are control results. Other results replace the value.
       # Return whether a change committed.
-      def modify(key) # rubocop:disable Naming/PredicateMethod
+      def modify(key, timeout: nil)
         raise LocalJumpError, "no block given" unless block_given?
         check_frozen!
         wrapped = wrap_key(key)
-        _, result = with_mutating_key_operation(wrapped, nil) do |reservation|
+        completed, result = with_mutating_key_operation(wrapped, timeout_deadline(timeout)) do |reservation|
           present, current = native_operation { [concurrent_key?(wrapped), concurrent_get(wrapped)] }
           value = yield(present, current)
           next false if MAP_KEEP.equal?(value)
@@ -231,7 +232,7 @@ module Farce
             changed!
           end
         end
-        !!result
+        completed && !!result
       end
 
       def upsert(key, initial_value, timeout: nil)
@@ -557,7 +558,8 @@ module Farce
             native_operation { concurrent_get(wrapped) }
           end
           return fallback&.call unless completed
-          ready = non_nil ? !current.nil? : !values_equal?(current, expected)
+          ready = non_nil ? !current.nil? :
+            Internal.value_changed?(current, expected, compare_values_by_identity?)
           return current if ready
           return fallback&.call unless wait_for_signal(@change_signal, generation, deadline)
         end
@@ -566,7 +568,7 @@ module Farce
       def wait_for_signal(signal, generation, deadline)
         return signal.wait(generation) unless deadline
 
-        remaining = deadline - Clock.now
+        remaining = Clock.remaining(deadline)
         return false unless remaining.positive?
         !signal.wait(generation, timeout: remaining).nil?
       end

data/lib/farce/engine/truffleruby/native/priority_queue.rb

@@ -23,8 +23,8 @@ module Farce
       private_constant :Bucket, :TrackedItem
 
       class State
-        attr_accessor :size, :sealed, :closed, :generation, :operation_owner
-        attr_reader :buckets, :capacity, :signal, :lock, :tracked_items, :track_age
+        attr_accessor :size, :sealed, :closed, :generation, :operation_owner, :capacity
+        attr_reader :buckets, :signal, :lock, :tracked_items, :track_age
 
         def initialize(capacity:, signal:, lock:, track_age:)
           @buckets = []
@@ -139,7 +139,18 @@ module Farce
         with_queue_operation(state) { state.size.zero? } # rubocop:disable Style/ZeroLengthPredicate
       end
 
-      def capacity = initialized_state.capacity
+      def capacity
+        state = initialized_state
+        with_queue_operation(state) { state.capacity }
+      end
+
+      def capacity=(value)
+        state = initialized_state
+        value = normalize_capacity(value)
+        with_queue_operation(state) do
+          notify_and_commit(state) { state.capacity = value }
+        end
+      end
 
       def clear
         state = initialized_state
@@ -262,7 +273,10 @@ module Farce
 
       def normalize_capacity(capacity)
         return nil if capacity.nil?
-        capacity = capacity.to_int unless primitive_is_a?(capacity, Integer)
+        unless primitive_is_a?(capacity, Integer)
+          raise TypeError, "capacity must be an Integer or nil" unless capacity.respond_to?(:to_int)
+          capacity = capacity.to_int
+        end
         raise TypeError, "capacity must be an Integer or nil" unless primitive_is_a?(capacity, Integer)
         raise ArgumentError, "capacity must be positive or nil" unless capacity.positive?
         capacity

data/lib/farce/engine/truffleruby/signal.rb

@@ -43,7 +43,7 @@ module Farce
               current = generation
               break current unless current == observed
 
-              remaining = deadline - Clock.now if deadline
+              remaining = Clock.remaining(deadline)
               break TIMED_OUT if remaining && !remaining.positive?
               @num_waiting.set(@num_waiting.get + 1) unless waiting
               waiting = true

data/lib/farce/integrations/concurrent.rb

@@ -3,9 +3,14 @@
 # warn_indent: true
 
 # @!group concurrent-ruby Integration
-require "farce"           unless defined?(Farce::Abstract)
-require "concurrent/map"  unless defined?(Concurrent::Map)
-require "concurrent/tvar" unless defined?(Concurrent::TVar)
+require "farce"                              unless defined?(Farce::Abstract)
+require "concurrent/map"                     unless defined?(Concurrent::Map)
+require "concurrent/tvar"                    unless defined?(Concurrent::TVar)
+require "concurrent/atomic/atomic_reference" unless defined?(Concurrent::AtomicReference)
+require "concurrent/atomic/atomic_fixnum"    unless defined?(Concurrent::AtomicFixnum)
+require "concurrent/atomic/atomic_boolean"   unless defined?(Concurrent::AtomicBoolean)
+require "concurrent/atomic/event"            unless defined?(Concurrent::Event)
+require "concurrent/atomic/count_down_latch" unless defined?(Concurrent::CountDownLatch)
 
 module Farce
   module Integrations
@@ -109,4 +114,12 @@ module Farce
   Internal::Converter.define(::Concurrent::Map, :Map) do |instance, value|
     value.each { instance[_1] = convert(_2) }
   end
+
+  Farce.on_main do
+    Subscription.define(::Concurrent::AtomicReference) { subscriber.value = it }
+    Subscription.define(::Concurrent::AtomicFixnum) { |_| subscriber.increment }
+    Subscription.define(::Concurrent::AtomicBoolean) { |_| subscriber.make_true }
+    Subscription.define(::Concurrent::Event) { |_| subscriber.set }
+    Subscription.define(::Concurrent::CountDownLatch) { |_| subscriber.count_down }
+  end
 end

data/lib/farce/internal/blocking_priority_queue.rb

@@ -32,7 +32,8 @@ module Farce
 
         wait(timeout) do
           raise_unwritable if sealed?
-          size < capacity
+          limit = capacity
+          !limit || size < limit
         end
       end
 
@@ -76,7 +77,7 @@ module Farce
         while true
           return true if internal_queue.push(priority, value)
           raise ThreadError, "queue full" if non_block
-          return false unless wait_push(timeout: remaining_timeout(deadline))
+          return false unless wait_push(timeout: Clock.remaining(deadline))
         end
       end
 
@@ -98,7 +99,7 @@ module Farce
           generation = internal_signal.generation
           raise ::Farce::ClosedQueueError, "queue is closed" if closed?
           return true if yield
-          return false unless internal_signal.wait(generation, timeout: remaining_timeout(deadline))
+          return false unless internal_signal.wait(generation, timeout: Clock.remaining(deadline))
         end
       end
 
@@ -111,12 +112,6 @@ module Farce
       def timeout_at(timeout)
         Clock.timeout(normalize_timeout(timeout)) unless timeout.nil?
       end
-
-      def remaining_timeout(timeout_at)
-        return unless timeout_at
-        timeout = timeout_at - Clock.now
-        timeout.positive? ? timeout : 0
-      end
     end
   end
 end

data/lib/farce/internal/flag_waiting.rb

@@ -21,7 +21,7 @@ module Farce
           observed = signal.generation
           current = value
           return current unless expected == current
-          break unless signal.wait(observed, timeout: Internal.remaining_timeout(deadline))
+          break unless signal.wait(observed, timeout: Clock.remaining(deadline))
         end
         yield if block_given?
       end

data/lib/farce/internal/lease_initialization.rb

@@ -31,7 +31,7 @@ module Farce
             reject_recursive_initialization!
             return unless wait
 
-            remaining = deadline - Clock.now if deadline
+            remaining = Clock.remaining(deadline)
             return if remaining && !remaining.positive?
             reject_unscheduled_fiber_wait!
             @signal.wait(observed, timeout: wait_interval(remaining))

data/lib/farce/internal/lease_pool_state.rb

@@ -108,7 +108,7 @@ module Farce
           return create_resource(factory) if reserve_creation
           return unless wait
 
-          remaining = deadline - Clock.now if deadline
+          remaining = Clock.remaining(deadline)
           raise TimeoutError, "lease pool checkout timed out" if remaining && !remaining.positive?
           interval = LeaseWaiting.wait_interval(remaining)
           changed  = Thread.handle_interrupt(Exception => :immediate) do

data/lib/farce/internal/lease_state.rb

@@ -156,7 +156,7 @@ module Farce
           resource = try_acquire(kind)
           return resource if resource
 
-          remaining = deadline - Clock.now if deadline
+          remaining = Clock.remaining(deadline)
           raise TimeoutError, "lease checkout timed out" if remaining && !remaining.positive?
           reject_unscheduled_fiber_wait!
           interval = wait_interval(remaining)
@@ -180,7 +180,7 @@ module Farce
           outcome  = try_acquire_block(block)
           return outcome.first if outcome
 
-          remaining = deadline - Clock.now if deadline
+          remaining = Clock.remaining(deadline)
           raise TimeoutError, "lease checkout timed out" if remaining && !remaining.positive?
           reject_unscheduled_fiber_wait!
           interval = wait_interval(remaining)

data/lib/farce/internal/local_executor_methods.rb

@@ -16,10 +16,10 @@ module Farce
       # Run a task directly, preserving its block, arguments, and calling fiber.
       # `mode` and `auto_local` follow the same validation as {#schedule}.
       # @param (see Abstract::Executor#execute)
-      # @return [self]
-      def execute(*, mode: :smart, auto_local: true, &)
+      # @return [self, nil]
+      def execute(*, mode: :smart, auto_local: true, timeout: nil, &)
         validate_local_mode(mode, auto_local)
-        super(*, mode: :local, auto_local: true, &)
+        super(*, mode: :local, auto_local: true, timeout:, &)
       end
 
       private

data/lib/farce/internal/map_value_modes.rb

@@ -143,18 +143,25 @@ module Farce
         end
       end
 
+      # (see Abstract::ConcurrentMap#wait_until)
+      def wait_until(key, timeout: nil)
+        raise LocalJumpError, "no block given" unless block_given?
+        result = Internal.wait_until(@map, key, timeout:) { |current| yield(unwrap_value(current)) }
+        unwrap_value(result)
+      end
+
       def wait_until_changed(key, expected, timeout: nil, &)
         prepared_key = @map.normalize_external_key(key)
         expected = wrap_comparison(expected)
         deadline = Internal.timeout_deadline(timeout)
         loop do
-          current = @map.get_prepared(prepared_key, timeout: Internal.remaining_timeout(deadline)) { TIMED_OUT }
+          current = @map.get_prepared(prepared_key, timeout: Clock.remaining(deadline)) { TIMED_OUT }
           return unwrap_result(current, &) if TIMED_OUT.equal?(current)
           return unwrap_value(current) unless values_equal?(nil.equal?(current) ? NIL_VALUE : current, expected)
           result = @map.wait_until_changed_prepared(
             prepared_key,
             current,
-            timeout: Internal.remaining_timeout(deadline),
+            timeout: Clock.remaining(deadline),
           ) { TIMED_OUT }
           return unwrap_result(result, &) if TIMED_OUT.equal?(result)
         end

data/lib/farce/internal/pool_settings.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+module Farce
+  module Internal # :nodoc: all
+    PoolSettings = Data.define(:min_size, :max_size, :max_inflight, :grow_after, :shrink_after, :generation)
+  end
+end

data/lib/farce/internal/pool_worker.rb

@@ -9,46 +9,59 @@ module Farce
       include Shareable::Unfreezable
 
       def initialize(pool)
-        @pool       = pool
-        @inflight   = Counter.new if pool.max_inflight || pool.shrink_after
-        @pressure   = pool.min_size < pool.max_size
+        @pool = pool
+        @inflight = Counter.new
         @registered = Atom.new(true)
         super()
       end
 
-      def idle_timeout = @pool.shrink_after
-
-      def wait_for_admission(scheduler, runnable_count)
-        return false if @pool.drained?
-        limit = @pool.max_inflight
-        return true unless limit
+      def settings = @pool.settings
+      def idle_timeout = settings.shrink_after
 
+      def wait_for_admission(scheduler, runnable_count, settings = self.settings)
         loop do
           return false if @pool.drained?
-          return true if @pool.closing? || @pool.at_max_size? || @inflight.value < limit
-          return true if runnable_count && scheduler.public_send(runnable_count).zero?
+          return settings if @pool.closing?
+          count = @pool.size
+          limit = settings.max_inflight
+          return false if count > settings.max_size && retire?(excess: true)
+          # Busy workers keep queued dependencies runnable until they become idle.
+          return settings if !limit || count >= settings.max_size || @inflight.value < limit
+          return settings if runnable_count && scheduler.public_send(runnable_count).zero?
 
+          # Read the generation before rechecking state to avoid a lost configuration wakeup.
           generation = @pool.admission_generation
-          next if @pool.closing? || @pool.at_max_size? || @inflight.value < limit
+          settings = self.settings
+          count = @pool.size
+          limit = settings.max_inflight
+          next if @pool.closing? || !limit || count >= settings.max_size || @inflight.value < limit
           @pool.wait_for_admission(generation)
+          settings = self.settings
         end
       end
 
-      def task_started
-        @inflight&.increment
-        @pool.task_taken if @pressure
+      def task_started(settings = self.settings)
+        @inflight.increment
+        @pool.task_taken(settings)
       end
 
       def task_finished
-        return unless @inflight
         @inflight.decrement
-        @pool.admission_changed if @pool.max_inflight && !@pool.at_max_size?
+        settings = self.settings
+        count = @pool.size
+        if count > settings.max_size
+          @inflight.value.zero? ? @pool.wake_retiring_workers : @pool.admission_changed
+        elsif settings.max_inflight && count < settings.max_size
+          @pool.admission_changed
+        end
       end
 
-      def retire?
-        return false unless @inflight&.value&.zero?
-        return false unless @pool.retire_worker
-        @registered.compare_and_set(true, false)
+      def retire?(excess: false, expected: nil)
+        return false unless @inflight.value.zero?
+        return false unless @pool.retire_worker(excess:, expected:)
+        retired = @registered.compare_and_set(true, false)
+        @pool.worker_retired if retired
+        retired
       end
 
       def stopped(error, replace: true) # rubocop:disable Naming/PredicateMethod

data/lib/farce/internal/reservation_waiting.rb

@@ -9,7 +9,7 @@ module Farce
     module ReservationWaiting
       def self.wait(signal, generation, deadline)
         while true
-          remaining = deadline - Clock.now if deadline
+          remaining = Clock.remaining(deadline)
           return false if remaining && !remaining.positive?
 
           # LeaseWaiting supplies the full remaining timeout on default engines

data/lib/farce/internal/scheduler_lifecycle.rb

@@ -146,8 +146,8 @@ module Farce
           service_policy
           break if idle?
           deadline = @timers.peek_priority
-          timeout = deadline ? deadline - Clock.now : nil
-          timeout = 0 if timeout&.negative? || ready? || !@mailbox.empty?
+          timeout = Clock.remaining(deadline)
+          timeout = 0 if ready? || !@mailbox.empty?
           dispatch(timeout, @timers.empty? ? @dispatch_budget : 256)
         end
 

data/lib/farce/internal/weak_map_value_modes.rb

@@ -24,6 +24,11 @@ module Farce
         super
       end
 
+      def replace_if_exists(key, replacement, mode: nil, **)
+        @manager.validate_mode!(mode)
+        super
+      end
+
       def store_if_absent(key, mode: nil, **)
         raise LocalJumpError, "no block given" unless block_given?
         @manager.validate_mode!(mode)