farce 0.1.0-aarch64-linux-gnu → 0.2.0-aarch64-linux-gnu

data/lib/farce/integrations.rb

@@ -10,6 +10,7 @@ module Farce
       active_support: %w[active_support active_support/core_ext].freeze,
       bson:           %w[bson].freeze,
       cbor:           %w[cbor].freeze,
+      date:           %w[date].freeze,
       dry_types:      %w[dry/types].freeze,
       concurrent:     %w[concurrent/map concurrent/tvar concurrent].freeze,
       json:           %w[json].freeze,
@@ -61,28 +62,6 @@ module Farce
     end
     private_constant :RequireHook
 
-    # A prepended singleton hook can recurse when Zeitwerk aliases it. Preserve
-    # the original method explicitly instead of relying on super here.
-    class << Kernel
-      alias farce_original_require require
-      private :farce_original_require
-
-      # Load a feature and its integration through Kernel.require.
-      # @api private
-      # @param path [String, #to_path] The feature to load.
-      # @return [Boolean] Whether the requested feature was newly loaded.
-      def require(path, ...)
-        path        = File.path(path)
-        result      = Integrations.loading(path) { farce_original_require(path, ...) }
-        integration = PATHS[path.delete_suffix(".rb")]
-        if integration && !Integrations.loading?(integration) && Farce.config.autoload_integrations
-          integration_path = "farce/integrations/#{integration}"
-          Integrations.loading(integration_path) { farce_original_require(integration_path) }
-        end
-        result
-      end
-    end
-
     private_constant :INTEGRATIONS, :PATHS
 
     extend self
@@ -106,8 +85,39 @@ module Farce
     # Activate integrations at startup when automatic loading is enabled.
     # @api private
     def setup
+      return unless Farce.config.autoload_integrations
+      install_require_hooks
+      load_active
+    end
+
+    # Install hooks once, including when automatic loading is enabled later.
+    # @api private
+    def install_require_hooks
+      return if Object.ancestors.include?(RequireHook)
+      # The instance hook handles ordinary require calls. The singleton alias
+      # chain handles Kernel.require, which bypasses Object's instance methods.
       Object.prepend(RequireHook)
-      load_active if Farce.config.autoload_integrations
+      # A prepended singleton hook can recurse when Zeitwerk aliases it. Preserve
+      # the original method explicitly instead of relying on super here.
+      class << Kernel
+        alias farce_original_require require
+        private :farce_original_require
+
+        # Load a feature and its integration through Kernel.require.
+        # @api private
+        # @param path [String, #to_path] The feature to load.
+        # @return [Boolean] Whether the requested feature was newly loaded.
+        def require(path, ...)
+          path        = File.path(path)
+          result      = Integrations.loading(path) { farce_original_require(path, ...) }
+          integration = PATHS[path.delete_suffix(".rb")]
+          if integration && !Integrations.loading?(integration) && Farce.config.autoload_integrations
+            integration_path = "farce/integrations/#{integration}"
+            Integrations.loading(integration_path) { farce_original_require(integration_path) }
+          end
+          result
+        end
+      end
     end
 
     # Loads all integrations for gems that have already been loaded.

data/lib/farce/internal/flag_waiting.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+module Farce
+  # @!visibility private
+  module Internal # :nodoc: all
+    module FlagWaiting
+      # Wait until the current value differs from the expected value.
+      # @param expected [Boolean] the value to wait to change from
+      # @param timeout [Numeric, nil] the total seconds available
+      # @yield called when the timeout expires
+      # @return [Boolean, BasicObject, nil] the changed value or timeout fallback
+      # @raise [ArgumentError] if expected is not true or false
+      def wait_until_changed(expected, timeout: nil)
+        unless expected.equal?(true) || expected.equal?(false)
+          raise ArgumentError, "expected value must be true or false"
+        end
+        signal = change_signal
+        Internal.with_timeout(timeout) do |_, deadline|
+          observed = signal.generation
+          current = value
+          return current unless expected == current
+          break unless signal.wait(observed, timeout: Internal.remaining_timeout(deadline))
+        end
+        yield if block_given?
+      end
+    end
+  end
+end

data/lib/farce/internal/freeze.rb

@@ -4,7 +4,7 @@
 
 module Farce
   module Internal
-    # Shared implementation for the explicit frozen-state policies in {Shareable}.
+    # Frozen-state policies for wrappers with separate backing storage.
     module Freeze
       # Structurally freeze a Ruby facade, then validate and publish its object graph.
       # This deliberately bypasses an override that controls logical frozen state.
@@ -20,14 +20,14 @@ module Farce
         raise FrozenError.new("can't modify frozen #{object.class}", receiver: object)
       end
 
-      # Delegate logical frozen state to storage owned by the wrapper.
+      # Freeze owned storage and the facade without freezing stored values.
       module Delegated
         def freeze
           backend = freeze_backend
           raise "#{self.class} is not initialized" unless backend
 
           backend.freeze
-          self
+          Object.instance_method(:freeze).bind_call(self)
         end
 
         def frozen?
@@ -39,6 +39,11 @@ module Farce
 
         def check_frozen! = Internal::Freeze.check(self)
 
+        def initialize_clone(other, freeze: nil)
+          super
+          self.freeze if is_a?(Farce::Unshareable) && (freeze.nil? ? other.frozen? : freeze)
+        end
+
         def publish_shareable_copy(other, operation:, freeze: nil)
           logically_frozen = operation == :clone && (freeze.nil? ? other.frozen? : freeze)
           self.freeze if logically_frozen

data/lib/farce/internal/map_value_modes.rb

@@ -18,7 +18,7 @@ module Farce
       # @param compare_by_identity [Boolean] the default comparison mode for keys and values
       # @param compare_keys_by_identity [Boolean] whether keys are compared by identity
       # @param compare_values_by_identity [Boolean] whether values are compared by identity
-      def initialize(initial_mapping = nil, mode: :copy, normalize_keys: nil, compare_by_identity: false,
+      def initialize(initial_mapping = nil, mode: :smart, normalize_keys: nil, compare_by_identity: false,
                      compare_keys_by_identity: compare_by_identity, compare_values_by_identity: compare_by_identity)
         initial_mapping = convert_entries(initial_mapping)
 

data/lib/farce/internal/scheduler_lifecycle.rb

@@ -15,7 +15,7 @@ module Farce
     module SchedulerLifecycle
       include Farce::Unshareable
 
-      # Prepending bypasses Unshareable's include hook, so remove freeze here.
+      # A live scheduler must keep updating its own lifecycle state.
       def self.prepended(scheduler)
         scheduler.undef_method(:freeze)
       end

data/lib/farce/lazy.rb

@@ -5,7 +5,7 @@
 module Farce
   # A ractor-shareable lazy value that is computed on demand.
   # The factory runs once. Its result is transferred according to {#mode}.
-  # With the default `:copy` mode, each Ractor receives its own cached copy.
+  # The default `:smart` mode prepares results using smart rules or dedicated proxies.
   # The factory and its bound receiver must remain Ractor-shareable.
   # Use {Strict::Lazy} for direct shareable results or {Unshared::Lazy} for local factories.
   #
@@ -63,15 +63,15 @@ module Farce
     include Shareable::Tracked
 
     # @!macro modes
-    # @overload initialize(factory, mode: :copy)
+    # @overload initialize(factory, mode: :smart)
     #   @param factory [Class, Proc, #call] the shareable factory for the value
     #   @param mode [Symbol] the transfer mode for the computed result
-    # @overload initialize(mode: :copy, self: nil)
+    # @overload initialize(mode: :smart, self: nil)
     #   @param mode [Symbol] the transfer mode for the computed result
     #   @param self [BasicObject] the shareable receiver to bind to the block
     #   @yield computes the value on first access
     #   @yieldreturn [BasicObject] the result to transfer
-    def initialize(factory = nil, mode: :copy, **, &)
+    def initialize(factory = nil, mode: :smart, **, &)
       @manager = marshal_mode_manager(mode)
       super(factory, **, &)
     end

data/lib/farce/lazy_ref.rb

@@ -6,7 +6,7 @@ module Farce
   # @!parse
   #   # A {Reference} for a {Lazy} value.
   #   #
-  #   # Results use the lazy value's transfer mode, which defaults to `:copy`.
+  #   # Results use the lazy value's transfer mode, which defaults to `:smart`.
   #   #
   #   # Calling `freeze` resolves and freezes the target. Checking `frozen?` before
   #   # the first successful freeze does not resolve it.
@@ -24,11 +24,11 @@ module Farce
   #   #   initialized.value # => 1
   #   class LazyRef < Farce::Reference
   #     # @!macro modes
-  #     # @overload initialize(factory, mode: :copy)
+  #     # @overload initialize(factory, mode: :smart)
   #     #   @param mode [Symbol] the transfer mode for the computed result
   #     #   @param [Class, Proc, #call] factory The factory to use for creating the value. Must be ractor-shareable.
   #     #
-  #     # @overload initialize(self: nil, mode: :copy)
+  #     # @overload initialize(self: nil, mode: :smart)
   #     #   @param mode [Symbol] the transfer mode for the computed result
   #     #   @yield The block to use for creating the value. Must be ractor-shareable.
   #     #   @yieldreceiver [BasicObject] The `self` parameter provided, or `nil` if not provided.

data/lib/farce/lfu_map.rb

@@ -13,7 +13,7 @@ module Farce
     # @param entries [Hash, Array<Array(BasicObject, BasicObject)>, Abstract::Map, #each, nil]
     #   Optional initial entries. Entries are stored sequentially and may be evicted.
     # @param mode [Symbol] The default value transfer mode.
-    def initialize(entries = nil, mode: :copy, **)
+    def initialize(entries = nil, mode: :smart, **)
       @manager = marshal_mode_manager(mode)
       super(entries, **)
     end

data/lib/farce/local/flag.rb

@@ -35,6 +35,9 @@ module Farce
       # @return [Boolean] the new value
       def store(value) = scoped_value.store(value)
 
+      # (see Abstract::Flag#wait_until_changed)
+      def wait_until_changed(...) = scoped_value.wait_until_changed(...)
+
       alias value= store
 
       # Replace the value and return its previous state.
@@ -60,6 +63,7 @@ module Farce
       end
 
       def new_scoped_value(...) = Internal::Flag.new(...)
+      def change_signal         = scoped_value.change_signal
     end
   end
 end

data/lib/farce/local/scoped.rb

@@ -74,7 +74,7 @@ module Farce
         def new_copied_scoped_value(map) = map
       end
 
-      MANAGER = ModeManager.new
+      MANAGER = ModeManager.new(mode: :copy)
       private_constant :MANAGER, :Map
 
       # @!visibility private

data/lib/farce/lru_map.rb

@@ -23,7 +23,7 @@ module Farce
     # @param entries [Hash, Array<Array(BasicObject, BasicObject)>, Abstract::Map, #each, nil]
     #   Optional initial entries. Entries are stored sequentially and may be evicted.
     # @param mode [Symbol] The default value transfer mode.
-    def initialize(entries = nil, mode: :copy, **)
+    def initialize(entries = nil, mode: :smart, **)
       @manager = marshal_mode_manager(mode)
       super(entries, **)
     end

data/lib/farce/map.rb

@@ -30,11 +30,11 @@ module Farce
   #   class Map
   #     # @!macro map_initialization
   #     # @!macro modes
-  #     # @param mode [Symbol] The default transfer mode for values. Defaults to `:copy`.
+  #     # @param mode [Symbol] The default transfer mode for values. Defaults to `:smart`.
   #     # @return [Map]
   #     def initialize(
   #       initial_mapping = nil,
-  #       mode: :copy,
+  #       mode: :smart,
   #       normalize_keys: nil,
   #       compare_by_identity: false,
   #       compare_keys_by_identity: compare_by_identity,

data/lib/farce/mode_manager/smart_rule.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+# shareable_constant_value: literal
+# warn_indent: true
+
+module Farce
+  class ModeManager
+    # Class for converting values based on smart rules.
+    class SmartRule
+      SMART_MODES = %i[smart smart_raise smart_move smart_copy].freeze
+      private_constant :SMART_MODES
+
+      include Shareable::Immutable
+
+      # @note This method must be called from the main ractor.
+      # Allows you to add rules for smart wrapping of specific classes.
+      #
+      # @overload define(klass, mode = nil)
+      #   @example
+      #     # Have smart modes use the :make_shareable mode for instances of MyClass
+      #     Farce::ModeManager::SmartRule.define(MyClass, :make_shareable)
+      #
+      #   @param klass [Class] the class to define a smart wrapping rule for
+      #   @param mode [Symbol] the mode to use when wrapping instances of the class
+      #
+      # @overload define(klass)
+      #   @example
+      #     # Have smart modes use a custom block for instances of MyClass
+      #     Farce::ModeManager::SmartRule.define(MyClass) do |value, mode_manager|
+      #       raise Ractor::Error, "#{value.inspect} cannot be shared" if value.dont_share?
+      #       mode_manager.wrap(value, mode: :make_shareable)
+      #     end
+      #
+      #   @param klass [Class] the class to define a smart wrapping rule for
+      #   @yield [value, mode_manager, mode] The block will be called when wrapping an instance of klass.
+      #   @yieldparam value [BasicObject] The value being wrapped.
+      #   @yieldparam mode_manager [Farce::ModeManager] The mode manager instance.
+      #   @yieldparam mode [Symbol] The mode to use when wrapping the value, like `:smart` or `:smart_copy`.
+      #   @yieldreturn [BasicObject] The shareable version of the value.
+      #
+      # @overload define(klass)
+      #   @example
+      #     Farce::ModeManager::SmartRule.define(MyClass) do
+      #       def smart_copy(value, mode_manager) = mode_manager.wrap(value, mode: :copy)
+      #       def smart_move(value, mode_manager) = mode_manager.wrap(value, mode: :move)
+      #     end
+      #
+      #   @yield block used for defining different methods for different smart modes.
+      #   @yieldreceiver [Class] The {SmartRule} subclass.
+      #
+      # @return [Class] the defined smart rule class.
+      def self.define(klass, mode = nil, &block)
+        SMART_RULES.define(klass) do
+          if mode
+            class_eval <<~RUBY, __FILE__, __LINE__ + 1
+              def call(value, mode_manager, _) = mode_manager.wrap(value, mode: #{mode.inspect})
+            RUBY
+          end
+
+          if block_given?
+            if block.arity.zero?
+              class_eval(&block)
+              SMART_MODES.each { private it if method_defined?(it) }
+            else
+              define_method(:call, &Ractor.shareable_lambda(&block))
+            end
+          end
+        end
+      end
+
+      # @api private
+      def call(value, mode_manager, mode)
+        register = mode_manager.register || Proxy.default_register
+        return Proxy.new(value, register:) if register.dedicated_proxy?(value.class)
+        __send__(mode, value, mode_manager)
+      rescue TypeError => e
+        raise unless e.message.include?("allocator undefined for")
+        raise Ractor::IsolationError, "#{value.inspect} cannot be shared"
+      end
+
+      # @api private
+      def marshal_dump = raise TypeError, "smart rules cannot be marshaled"
+
+      private
+
+      # smart is intentionally not an alias
+      def smart(value, mode_manager)      = smart_raise(value, mode_manager)
+      def smart_raise(value, _)           = raise Ractor::IsolationError, "#{value.inspect} cannot be shared"
+      def smart_move(value, mode_manager) = mode_manager.wrap(value, mode: :move)
+
+      def smart_copy(value, mode_manager)
+        mode_manager.wrap(value, mode: :copy)
+      rescue StandardError => e
+        begin
+          mode_manager.wrap(value, mode: :marshal)
+        rescue StandardError
+          raise e, cause: e.cause
+        end
+      end
+    end
+
+    SMART_RULES = ClassMirror.new(SmartRule) { |klass, _| klass.new }
+    private_constant :SMART_RULES
+
+    SmartRule.define(Time, :make_shareable)
+
+    [Array, ::Set].each do |klass|
+      SmartRule.define(klass) do
+        def smart_copy(value, mode_manager)
+          all_shareable = true
+          mapped = value.dup.map! do |entry|
+            result = mode_manager.wrap(entry, mode: :smart_raise)
+            if mode_manager.managed_envelope?(result)
+              all_shareable = false
+              entry
+            else
+              result
+            end
+          rescue StandardError
+            all_shareable = false
+            entry
+          end
+          return super unless all_shareable
+          Ractor.make_shareable(mapped)
+        end
+
+        def smart(value, mode_manager)
+          return super unless value.all? { Ractor.shareable?(it) }
+          Ractor.make_shareable(value)
+        end
+      end
+    end
+
+    SmartRule.define(Hash) do |value, mode_manager, mode|
+      return super(value, mode_manager, mode) unless value.all? { _1.is_a?(Symbol) && Ractor.shareable?(_2) }
+      Ractor.make_shareable(value)
+    end
+  end
+end

data/lib/farce/mode_manager.rb

@@ -2,6 +2,8 @@
 # shareable_constant_value: literal
 # warn_indent: true
 
+require "farce/mode_manager/smart_rule"
+
 module Farce
   # A mode manager encapsulates logic for dealing with Ruby objects that aren't Ractor-shareable.
   # It is a perfect companion piece for APIs that require Ractor-shareable objects.
@@ -17,7 +19,7 @@ module Farce
   # class MyQueue
   #   include Farce::Shareable
   #
-  #   def initialize(capacity: 1024, mode: :copy)
+  #   def initialize(capacity: 1024, mode: :smart)
   #     @queue   = Ratomic::Queue.new(capacity)
   #     @manager = Farce::ModeManager.new(mode:)
   #   end
@@ -55,10 +57,13 @@ module Farce
     # @return [Symbol] The default mode to use when wrapping values.
     attr_reader :mode
 
+    # @return [Farce::Proxy::Register, nil] The register used for generating Farce::Proxy instances.
+    attr_reader :register
+
     # @!macro modes
     # @param mode [Symbol] The default mode to use when wrapping values. Must be one of the valid modes.
     # @param register [Proxy::Register, nil] The register to use for generating Farce::Proxy instances.
-    def initialize(mode: :copy, register: nil)
+    def initialize(mode: :smart, register: nil)
       raise ArgumentError, "invalid mode: #{mode.inspect}" unless Farce::MODES.include?(mode)
       @mode     = mode
       @register = register
@@ -87,7 +92,10 @@ module Farce
     def wrap(value, mode: nil)
       return value if Ractor.shareable?(value)
 
-      case mode || self.mode
+      case mode ||= self.mode
+      when :smart, :smart_copy, :smart_move, :smart_raise
+        return Ractor.make_shareable(-value) if value.is_a?(String)
+        SMART_RULES[value.class].call(value, self, mode)
       when :copy           then Envelope::Copy.new(value, self)
       when :dedup          then Ractor.make_shareable(Farce.dedup(value))
       when :local          then Envelope::Local.new(value, self)
@@ -97,6 +105,7 @@ module Farce
       when :raise          then raise Ractor::IsolationError, "value is not Ractor-shareable: #{value.inspect}"
       when :shareable_copy then Ractor.make_shareable(value, copy: true)
       when :proxy          then Proxy.new(value, register: @register)
+      when :marshal        then Envelope::Marshal.new(value, self)
       else raise ArgumentError, "invalid mode: #{mode.inspect}"
       end
     end

data/lib/farce/molecule.rb

@@ -21,7 +21,7 @@ module Farce
     # Create a record class with defaults for newly created atoms.
     # @!macro modes
     # @param fields [Array<Symbol, String>] the field names
-    # @param mode [Symbol, nil] the default transfer mode, or nil for :copy
+    # @param mode [Symbol, nil] the default transfer mode, or nil for :smart
     # @param compare_by_identity [Boolean, nil] the default comparison policy
     # @return [Class<Molecule>]
     def self.define(*fields, mode: nil, **, &)
@@ -32,7 +32,7 @@ module Farce
     end
 
     # @return [Symbol] the default transfer mode for new records
-    def self.default_mode = :copy
+    def self.default_mode = :smart
 
     # @!visibility private
     def self.define_member(field)

data/lib/farce/pool.rb

@@ -111,7 +111,7 @@ module Farce
     # @yield [*args] Task to execute.
     # @return [Pool] self.
     # @raise [PoolClosedError] If the pool is closing or closed.
-    def schedule(*args, mode: :copy, auto_local: true, &block) # rubocop:disable Lint/UnusedMethodArgument
+    def schedule(*args, mode: :smart, auto_local: true, &block) # rubocop:disable Lint/UnusedMethodArgument
       raise PoolClosedError, "cannot schedule task on a closed pool" if closed?
       raise ArgumentError, "local transfer is not supported by a pool" if mode == :local
 

data/lib/farce/port.rb

@@ -12,9 +12,9 @@ module Farce
   class Port < Internal::Port
     include Abstract::Port
 
-    MANAGER    = ModeManager.new
+    MANAGER    = ModeManager.new(mode: :smart_copy)
     SUBCLASSES = Farce::MODES.to_h do |mode|
-      if mode == :copy
+      if mode == :smart_copy
         normal = self
       else
         normal = Class.new(self)
@@ -41,7 +41,7 @@ module Farce
     end
 
     # @api private
-    def self.mode = :copy
+    def self.mode = :smart_copy
 
     # @api private
     def self.auto_local? = false
@@ -54,7 +54,7 @@ module Farce
       self[mode || self.mode, auto_local: auto_local].new
     end
 
-    # @!method initialize(mode: :copy, auto_local: false)
+    # @!method initialize(mode: :smart_copy, auto_local: false)
     #   Creates a new port with the given default mode.
     #
     #   @!macro modes

data/lib/farce/priority_queue.rb

@@ -11,7 +11,7 @@ module Farce
     # (see Farce::Abstract::PriorityQueue#initialize)
     # @!macro modes
     # @param mode [Symbol] the default mode for sending unshareable values
-    def initialize(capacity: nil, default_priority: 0, order: :ascending, mode: :copy, track_age: false)
+    def initialize(capacity: nil, default_priority: 0, order: :ascending, mode: :smart, track_age: false)
       @manager = ModeManager.new(mode:)
       super(capacity:, default_priority:, order:, track_age:)
     end

data/lib/farce/proxy/register.rb

@@ -87,6 +87,12 @@ module Farce
         end
       end
 
+      # Check whether this exact class has a definition in either proxy layer.
+      # Inherited wrapper methods do not count as a dedicated proxy.
+      # @param klass [Class] the source class
+      # @return [Boolean] whether the class has a dedicated proxy
+      def dedicated_proxy?(klass) = @inner_mirror.custom?(klass) || @outer_mirror.custom?(klass)
+
       private
 
       def mirror_for(layer)

data/lib/farce/proxy/supervisor.rb

@@ -120,7 +120,7 @@ module Farce
           rescue Exception => e # rubocop:disable Lint/RescueException
             request.success.value = false
             begin
-              result = @mode_manager.wrap(e)
+              result = @mode_manager.wrap(e, mode: :copy)
             rescue StandardError
               result = -"#{e.class}: #{e.message}"
             end

data/lib/farce/proxy.rb

@@ -50,13 +50,18 @@ module Farce
   # ```
   #
   # The above example has one issue:
-  # We cannot chain the calls, because `<<` returns an array, which actually gets copied.
+  # By default, `<<` makes the returned array shareable and freezes it.
+  # The next mutation raises `FrozenError`.
   #
   # ```ruby
   # my_instance = MyClass.new
   # my_proxy    = Farce::Proxy.create(my_instance)
   #
-  # Ractor.new(my_proxy) { it << 42 << 43 }.join
+  # Ractor.new(my_proxy) do |proxy|
+  #   proxy << 42 << 43
+  # rescue FrozenError
+  #   :frozen_result
+  # end.join
   #
   # my_instance.record # => [42]
   # ```

data/lib/farce/queue.rb

@@ -11,7 +11,7 @@ module Farce
     # (see Farce::Abstract::Queue#initialize)
     # @!macro modes
     # @param mode [Symbol] the default mode for sending unshareable values
-    def initialize(capacity: 1024, mode: :copy, track_age: false)
+    def initialize(capacity: 1024, mode: :smart, track_age: false)
       @manager = ModeManager.new(mode:)
       @queue = Internal::Queue.new(capacity:, track_age:)
       super()

data/lib/farce/scheduler.rb

@@ -326,14 +326,14 @@ module Farce
     #
     # @param args [Array<Object>] Positional arguments passed to the task block.
     # @param mode [Symbol]
-    #   Argument transfer mode: `:copy`, `:move`, `:local`, `:make_shareable`, `:shareable_copy`, or `:raise`.
+    #   Argument transfer mode from {Farce::MODES}, including `:copy`, `:marshal`, and `:local`.
     #   See {ModeManager#wrap}.
     # @param auto_local [Boolean] Whether to override mode with `:local` in the owning Ractor.
     # @yield [*args] The task to execute.
     # @return [Scheduler] self.
     # @raise [SchedulerClosedError] If the handle is closing, closed, or in an error state.
     # @see Ractor.shareable_proc
-    def schedule(*args, mode: :copy, auto_local: true, &block)
+    def schedule(*args, mode: :smart, auto_local: true, &block)
       raise SchedulerClosedError, "cannot schedule task on a closed scheduler" if closed?
 
       if auto_local

data/lib/farce/set.rb

@@ -30,7 +30,7 @@ module Farce
     private
 
     def initialize_value_mode(mode)
-      mode = :copy if UNDEFINED.equal?(mode)
+      mode = :smart if UNDEFINED.equal?(mode)
       @manager = ModeManager.new(mode:)
     end
 

data/lib/farce/sorted_set.rb

@@ -24,7 +24,7 @@ module Farce
     private
 
     def initialize_value_mode(mode)
-      mode = :copy if UNDEFINED.equal?(mode)
+      mode = :smart if UNDEFINED.equal?(mode)
       @manager = ModeManager.new(mode:)
     end