solid_objects 0.11.0 → 0.12.1

data/docs/realtime.md

@@ -65,6 +65,27 @@ listed in `observes:` raises `UnknownComponentDependency`. This keeps
 invalidation correct and prevents a partial from silently depending on state
 that cannot wake it.
 
+Observable values are shared projections. By default, each changed value is
+stored in the broadcast outbox and can be sent as a scalar Turbo replacement to
+every subscriber that passes `authorize_subscription`. Authorization to the
+actor stream is not a per-viewer projection.
+
+For a component dependency whose value must never enter the durable outbox or
+Action Cable frame, declare it invalidation-only:
+
+```ruby
+observable :player_one, broadcast: :invalidation do
+  player_in_seat(1)
+end
+```
+
+The runtime still compares the value around each successful turn and uses a
+change to refresh components, but stores `{}` and renders no scalar Turbo
+replacement. An invalidation-only observable therefore cannot be used as a
+scalar value such as `actor.player_one`. The component endpoint reads the
+latest committed value and authorizes it again; subscriber-specific state
+belongs in `broadcast_payload`.
+
 ```erb
 <ul>
   <% actor.recent_messages.each do |message| %>
@@ -416,7 +437,8 @@ component key, locals, or DOM ID.
 ## Broadcast durability
 
 The actor's fenced commit compares observables before and after the turn and
-inserts one broadcast row per changed value. The actor state, monotonic
+inserts one broadcast row per changed observable. Value-broadcast observables
+store the changed JSON value; invalidation-only observables store `{}`. The actor state, monotonic
 `state_revision`, message completion, and broadcast rows commit atomically. A
 rolled-back or fenced-out turn therefore cannot invalidate a component.
 
@@ -456,8 +478,8 @@ response revision fencing.
 ## Cost model
 
 The durable row cost is unchanged: one broadcast row per changed observable,
-containing its JSON value and the message/instance references needed to derive
-invalidation metadata. No rendered document is stored. Each affected component
+containing either its JSON value or an empty invalidation marker plus the
+message/instance references needed to derive invalidation metadata. No rendered document is stored. Each affected component
 adds one authorized GET and one partial render per non-coalesced state
 revision. A repeated keyed component adds one GET and render per key. Signed
 locals increase page and Cable subscription bytes but do not create durable

data/docs/roadmap.md

@@ -4,7 +4,7 @@
 
 - Rails engine, install generator, migration, and CLI
 - Explicit actor registry, references, JSON state, and state migrations
-- Direct synchronous RPC, explicit `sync`, and durable `async`
+- Fluent direct synchronous RPC, configured `sync`, and durable `async`
 - Durable message history plus ready/claimed membership tables
 - Concurrent sequence allocation and actor creation
 - Activation leases, renewal, unique activation tokens, generations, and
@@ -12,7 +12,8 @@
 - Bounded activation passes, idle cache, hot-actor yield, and process records
 - At-least-once retries, terminal domain rejection, strict poison ordering,
   dead letters, and tail retry
-- Transactional effects with success/failure actor messages
+- Transactional effects with success/failure actor messages carrying the
+  originally staged arguments for callback correlation
 - Actor-to-actor asynchronous outbox delivery. Effects and broadcasts use
   portable status rows with polling indexes and database check constraints on
   status, which works on all three adapters; a future version may add narrow
@@ -23,8 +24,10 @@
   listed here while broken in that worker: the scheduler reached a constant the
   caller path happened to load, so reminders never fired in production and
   every in-process test still passed
-- Durable observable invalidations, scalar Turbo replacement, keyed ERB
-  components, signed component locals, and authorized replace or morph refresh
+- Durable value or invalidation-only observable broadcasts, scalar Turbo
+  replacement, keyed ERB components, signed component locals, and authorized
+  replace or morph refresh. Invalidation-only observables retain component
+  change detection while storing and broadcasting no projected value
 - Batched component refreshes: components sharing a signed `batch:` collapse to
   one browser request per revision, served as HTML frames in a JSON envelope
 - Personalized state payload broadcasts computed per subscriber under that
@@ -45,7 +48,8 @@
 - Bounded message/process pruning, actor-type opt-in instance expiration,
   graceful caller shutdown, committed state snapshots, and an opt-in Minitest
   helper that clears every actor-owned table itself rather than relying on the
-  database cascade, which a host application may not enforce
+  database cascade, which a host application may not enforce, and runs due
+  reminders against an explicit test time without moving the database clock
 - Supervisor role replacement: a role whose thread dies is restarted until
   shutdown is requested, and dead process records plus expired message and
   process history are pruned on their own intervals without an application

data/docs/security.md

@@ -36,6 +36,14 @@ Opaque stream and DOM names reduce accidental disclosure but do not replace
 authorization. Signed stream tokens are readable by their recipient and prove
 integrity only.
 
+Every normal observable value is stored in the broadcast outbox and can reach
+every subscriber that passes `authorize_subscription` for the actor. Never put
+credentials, session identifiers, private cards, hidden library order, or any
+other subscriber-specific state in a value-broadcast observable. Declare a
+component dependency with `broadcast: :invalidation` when only change metadata
+may cross the shared stream, or use `broadcast_payload` for a projection that
+must be computed separately for each authorized connection.
+
 ## Serialization
 
 The built-in serializer accepts JSON-compatible data, normalizes keys to

data/examples/application/app/actors/shopping_cart_actor.rb

@@ -64,14 +64,14 @@ class ShoppingCartActor < SolidObjects::Actor
     )
   end
 
-  def payment_succeeded(effect_id:, result:)
+  def payment_succeeded(effect_id:, arguments:, result:)
     return unless checkout_status == "pending"
-    return unless result.fetch("payment_id") == payment_id
+    return unless arguments.fetch("payment_id") == payment_id
 
     self.checkout_status = "paid"
   end
 
-  def payment_failed(effect_id:, error:)
+  def payment_failed(effect_id:, arguments:, error:)
     return unless checkout_status == "pending"
 
     self.checkout_status = "payment_failed"

data/lib/solid_objects/actor.rb

@@ -2,10 +2,10 @@
 
 module SolidObjects
   class Actor
-    EffectIntent = Data.define(:name, :arguments, :success_message_name, :failure_message_name)
+    EffectIntent = Data.define(:name, :arguments, :success_operation, :failure_operation)
     CommitActionIntent = Data.define(:name, :arguments)
     ReminderIntent = Data.define(:name, :at, :arguments, :interval_seconds, :missed_policy)
-    OutboundMessageIntent = Data.define(:actor_type, :actor_id, :message_name, :arguments, :available_at, :idempotency_key)
+    OutboundMessageIntent = Data.define(:actor_type, :actor_id, :operation, :arguments, :available_at, :idempotency_key)
 
     class << self
       # @rbs (Class) -> void
@@ -52,9 +52,9 @@ module SolidObjects
         definition.add_query(name, block)
       end
 
-      # @rbs (Symbol | String) ?{ () -> untyped } -> ActorDefinition::Handler
-      def observable(name, &block)
-        definition.add_observable(name, block)
+      # @rbs (Symbol | String, ?broadcast: Symbol) ?{ () -> untyped } -> ActorDefinition::Handler
+      def observable(name, broadcast: :value, &block)
+        definition.add_observable(name, block, broadcast:)
       end
 
       # @rbs (Symbol | String) { (untyped, untyped) -> untyped } -> ActorDefinition::Handler
@@ -72,7 +72,7 @@ module SolidObjects
 
       # @rbs (from: Integer, to: Integer) { (Hash[String, untyped]) -> Hash[String, untyped] } -> ActorDefinition::StateMigration
       def migrate_state(from:, to:, &block)
-        definition.add_state_migration(from, to, block)
+        definition.add_state_migration(from:, to:, block:)
       end
 
       # @rbs () { () -> untyped } -> Proc
@@ -163,8 +163,9 @@ module SolidObjects
     # @rbs (Symbol | String, String, ?details: Hash[String | Symbol, untyped]) -> bot
     def reject(code, message, details: {})
       rejection_code = code.to_s
-      unless rejection_code.match?(/\A[a-z][a-z0-9_]*\z/)
-        raise ArgumentError, "rejection code must contain lowercase letters, digits, and underscores"
+      unless rejection_code.match?(/\A[A-Za-z_][A-Za-z0-9_]*\z/)
+        raise InvalidRejectionCode,
+          "invalid rejection code #{rejection_code.inspect}; expected a letter or underscore followed by letters, digits, or underscores"
       end
 
       raise Rejected.new(code: rejection_code, message:, details:)
@@ -177,8 +178,8 @@ module SolidObjects
       EffectIntent.new(
         name: name.to_s,
         arguments: Serialization.dump(arguments),
-        success_message_name: on_success&.to_s,
-        failure_message_name: on_failure&.to_s
+        success_operation: on_success&.to_s,
+        failure_operation: on_failure&.to_s
       ).tap do |intent|
         effect_intents << intent
       end
@@ -196,8 +197,8 @@ module SolidObjects
       nil
     end
 
-    # @rbs (Symbol | String, at: Time, ?every: Numeric?, ?missed: Symbol | String, arguments: Hash[Symbol | String, untyped]) -> nil
-    def schedule(name, at:, every: nil, missed: :latest, arguments: {})
+    # @rbs (at: Time, ?every: Numeric?, ?missed: Symbol | String) -> OperationDispatcher
+    def schedule(at:, every: nil, missed: :latest)
       interval_seconds = every&.to_f
       if interval_seconds && !interval_seconds.positive?
         raise ArgumentError, "reminder interval must be positive"
@@ -207,31 +208,42 @@ module SolidObjects
         raise ArgumentError, "missed reminder policy must be all or latest"
       end
 
-      ReminderIntent.new(
-        name: name.to_s,
-        at:,
-        arguments: Serialization.dump(arguments),
-        interval_seconds:,
-        missed_policy:
-      ).tap do |intent|
-        reminder_intents << intent
+      OperationDispatcher.new(
+        actor_type: self.class.actor_type,
+        handlers: self.class.definition.messages
+      ) do |operation, arguments|
+        ReminderIntent.new(
+          name: operation.to_s,
+          at:,
+          arguments: Serialization.dump(arguments),
+          interval_seconds:,
+          missed_policy:
+        ).tap do |intent|
+          reminder_intents << intent
+        end
+        nil
       end
-      nil
     end
 
-    # @rbs (Reference, Symbol | String, ?available_at: Time?, ?idempotency_key: String?, **untyped) -> nil
-    def send_to(reference, message_name, available_at: nil, idempotency_key: nil, **arguments)
-      stage_outbound_message(reference, message_name, arguments, available_at:, idempotency_key:)
-      nil
+    # @rbs (Reference, ?available_at: Time?, ?idempotency_key: String?) -> OperationDispatcher
+    def send_to(reference, available_at: nil, idempotency_key: nil)
+      actor_class = SolidObjects.registry.fetch(reference.actor_type)
+      OperationDispatcher.new(
+        actor_type: reference.actor_type,
+        handlers: actor_class.definition.messages
+      ) do |operation, arguments|
+        stage_outbound_message(reference:, operation:, arguments:, available_at:, idempotency_key:)
+        nil
+      end
     end
 
     # @rbs (Symbol | String, Hash[String, untyped]) -> untyped
-    def invoke(message_name, arguments)
-      handler = self.class.definition.messages[message_name.to_sym] ||
-        self.class.definition.queries[message_name.to_sym]
-      raise UnknownMessage, "unknown message #{message_name.inspect} for #{self.class.actor_type}" unless handler
+    def invoke(operation, arguments)
+      handler = self.class.definition.messages[operation.to_sym] ||
+        self.class.definition.queries[operation.to_sym]
+      raise UnknownMessage, "unknown operation #{operation.inspect} for #{self.class.actor_type}" unless handler
 
-      guard_application_writes(message_name.to_s) do
+      guard_application_writes(operation.to_s) do
         instance_exec(**keyword_arguments(arguments), &handler.block)
       end
     end
@@ -270,12 +282,12 @@ module SolidObjects
       end
     end
 
-    # @rbs (Reference, Symbol | String, Hash[Symbol | String, untyped], ?available_at: Time?, idempotency_key: String?) -> OutboundMessageIntent
-    def stage_outbound_message(reference, message_name, arguments, available_at: nil, idempotency_key: nil)
+    # @rbs (reference: Reference, operation: Symbol | String, arguments: Hash[Symbol | String, untyped], ?available_at: Time?, idempotency_key: String?) -> OutboundMessageIntent
+    def stage_outbound_message(reference:, operation:, arguments:, available_at: nil, idempotency_key: nil)
       OutboundMessageIntent.new(
         actor_type: reference.actor_type,
         actor_id: reference.actor_id,
-        message_name: message_name.to_s,
+        operation: operation.to_s,
         arguments: Serialization.dump(arguments),
         available_at:,
         idempotency_key:
@@ -333,11 +345,11 @@ module SolidObjects
     end
 
     # @rbs (Symbol | String?) -> void
-    def validate_effect_callback!(message_name)
-      return unless message_name
-      return if self.class.definition.messages.key?(message_name.to_sym)
+    def validate_effect_callback!(operation)
+      return unless operation
+      return if self.class.definition.messages.key?(operation.to_sym)
 
-      raise UnknownMessage, "unknown effect callback message #{message_name.inspect}"
+      raise UnknownMessage, "unknown effect callback operation #{operation.inspect}"
     end
   end
 end

data/lib/solid_objects/actor_channel.rb

@@ -32,9 +32,9 @@ module SolidObjects
       snapshot = ActorSnapshot.new(reference)
       scalar_observable_names(snapshot).each do |name|
         transmit TurboStreamRenderer.observable_value(
-          reference,
-          name,
-          snapshot.observable_value(name)
+          reference:,
+          name:,
+          value: snapshot.observable_value(name)
         )
       end
       refresh_outdated_components(snapshot)
@@ -165,13 +165,13 @@ module SolidObjects
     def validate_scalar_observables!
       return unless scalar_observables
 
-      observables = SolidObjects
+      definition = SolidObjects
         .registry
         .fetch(reference.actor_type)
         .definition
-        .observables
       unknown = scalar_observables.find do |name|
-        !observables.key?(name.to_sym)
+        !definition.observables.key?(name.to_sym) ||
+          !definition.broadcasts_observable_value?(name)
       end
       return unless unknown
 
@@ -182,7 +182,10 @@ module SolidObjects
     def scalar_observable_names(snapshot)
       return scalar_observables if scalar_observables
 
-      snapshot.actor_class.definition.observables.keys.map(&:to_s)
+      definition = snapshot.actor_class.definition
+      definition.observables.keys.filter_map do |name|
+        name.to_s if definition.broadcasts_observable_value?(name)
+      end
     end
   end
 end

data/lib/solid_objects/actor_definition.rb

@@ -9,6 +9,7 @@ module SolidObjects
     # @rbs @messages: Hash[Symbol, Handler]
     # @rbs @queries: Hash[Symbol, Handler]
     # @rbs @observables: Hash[Symbol, Handler]
+    # @rbs @observable_broadcasts: Hash[Symbol, Symbol]
     # @rbs @payload_broadcasts: Hash[Symbol, Handler]
     # @rbs @state_version: Integer
     # @rbs @state_migrations: Array[StateMigration]
@@ -33,6 +34,7 @@ module SolidObjects
       @messages = {}
       @queries = {}
       @observables = {}
+      @observable_broadcasts = {}
       @payload_broadcasts = {}
       @state_version = 1
       @state_migrations = []
@@ -45,6 +47,7 @@ module SolidObjects
     # @rbs (Symbol | String, default: untyped) -> StateDefinition::Attribute
     def add_attribute(name, default:)
       attribute_name = name.to_sym
+      OperationDispatcher.validate_operation_name!(attribute_name)
       if messages.key?(attribute_name) || queries.key?(attribute_name)
         raise InvalidActor, "#{attribute_name.inspect} is already defined"
       end
@@ -60,7 +63,7 @@ module SolidObjects
 
     # @rbs (Symbol | String, Proc) -> Handler
     def add_message(name, block)
-      add_handler(messages, name, block)
+      add_handler(collection: messages, name:, block:)
     end
 
     # @rbs (Symbol | String, Proc) -> Handler
@@ -72,20 +75,29 @@ module SolidObjects
         end
       end
 
-      add_handler(queries, name, block)
+      add_handler(collection: queries, name:, block:)
     end
 
-    # @rbs (Symbol | String, Proc?) -> Handler
-    def add_observable(name, block = nil)
+    # @rbs (Symbol | String, Proc?, broadcast: Symbol) -> Handler
+    def add_observable(name, block = nil, broadcast:)
       observable_name = name.to_sym
       raise InvalidActor, "#{observable_name.inspect} observable is already defined" if observables.key?(observable_name)
+      unless %i[value invalidation].include?(broadcast)
+        raise InvalidActor, "observable broadcast must be :value or :invalidation"
+      end
 
       observable_block = block || -> { state.fetch(observable_name) }
       Handler.new(name: observable_name, block: observable_block).tap do |handler|
         observables[observable_name] = handler
+        observable_broadcasts[observable_name] = broadcast
       end
     end
 
+    # @rbs (Symbol | String) -> bool
+    def broadcasts_observable_value?(name)
+      observable_broadcasts.fetch(name.to_sym) == :value
+    end
+
     # @rbs (Symbol | String, Proc) -> Handler
     def add_payload_broadcast(name, block)
       payload_name = name.to_sym
@@ -121,8 +133,8 @@ module SolidObjects
       @state_version = version
     end
 
-    # @rbs (Integer, Integer, Proc) -> StateMigration
-    def add_state_migration(from, to, block)
+    # @rbs (from: Integer, to: Integer, block: Proc) -> StateMigration
+    def add_state_migration(from:, to:, block:)
       unless to == from + 1
         raise InvalidActor, "state migrations must advance exactly one version"
       end
@@ -167,6 +179,7 @@ module SolidObjects
         copy.instance_variable_set(:@messages, messages.dup)
         copy.instance_variable_set(:@queries, queries.dup)
         copy.instance_variable_set(:@observables, observables.dup)
+        copy.instance_variable_set(:@observable_broadcasts, observable_broadcasts.dup)
         copy.instance_variable_set(:@payload_broadcasts, payload_broadcasts.dup)
         copy.instance_variable_set(:@state_version, state_version)
         copy.instance_variable_set(:@state_migrations, state_migrations.dup)
@@ -179,10 +192,11 @@ module SolidObjects
 
     private
 
-    attr_reader :attribute_queries, :method_messages
+    attr_reader :attribute_queries, :method_messages, :observable_broadcasts
 
     # @rbs (Symbol) -> Handler
     def add_method_message(name)
+      OperationDispatcher.validate_operation_name!(name)
       if messages.key?(name) || queries.key?(name)
         raise InvalidActor, "#{name.inspect} is already defined"
       end
@@ -222,9 +236,10 @@ module SolidObjects
       end
     end
 
-    # @rbs (Hash[Symbol, Handler], Symbol | String, Proc) -> Handler
-    def add_handler(collection, name, block)
+    # @rbs (collection: Hash[Symbol, Handler], name: Symbol | String, block: Proc) -> Handler
+    def add_handler(collection:, name:, block:)
       handler_name = name.to_sym
+      OperationDispatcher.validate_operation_name!(handler_name)
       raise InvalidActor, "#{handler_name.inspect} is already defined" if messages.key?(handler_name) || queries.key?(handler_name)
 
       Handler.new(name: handler_name, block:).tap { |handler| collection[handler_name] = handler }

data/lib/solid_objects/actor_view.rb

@@ -24,8 +24,13 @@ module SolidObjects
     # @rbs (Symbol | String) -> untyped
     def value(name)
       observable_name = name.to_sym
-      handler = snapshot.actor_class.definition.observables[observable_name]
+      definition = snapshot.actor_class.definition
+      handler = definition.observables[observable_name]
       raise UnknownMessage, "unknown observable #{name.inspect}" unless handler
+      unless definition.broadcasts_observable_value?(observable_name)
+        raise ArgumentError,
+          "invalidation-only observable #{observable_name.inspect} cannot render as a scalar target"
+      end
 
       authorize_read!(observable_name)
       value = snapshot.observable_value(observable_name)
@@ -154,7 +159,7 @@ module SolidObjects
       authorized = SolidObjects.configuration.authorize_query.call(
         actor_type: reference.actor_type,
         actor_id: reference.actor_id,
-        message_name: name.to_s,
+        operation: name.to_s,
         arguments: {},
         authorization_context:
       )

data/lib/solid_objects/application_write_guard.rb

@@ -16,7 +16,7 @@ module SolidObjects
         raise ApplicationWriteForbidden.new(
           actor_type:,
           actor_id:,
-          message_name: operation
+          operation:
         )
       end
     end

data/lib/solid_objects/client.rb

@@ -12,50 +12,50 @@ module SolidObjects
       @mailbox = mailbox
     end
 
-    # @rbs (Reference, Symbol | String, Hash[Symbol | String, untyped], ?available_at: Time?, ?idempotency_key: String?, ?authorization_context: untyped) -> MessageReference
-    def async(reference, message_name, arguments, available_at: nil, idempotency_key: nil, authorization_context: nil)
+    # @rbs (reference: Reference, operation: Symbol | String, arguments: Hash[Symbol | String, untyped], ?available_at: Time?, ?idempotency_key: String?, ?authorization_context: untyped) -> MessageReference
+    def async(reference:, operation:, arguments:, available_at: nil, idempotency_key: nil, authorization_context: nil)
       actor_class = SolidObjects.registry.fetch(reference.actor_type)
-      message_symbol = message_name.to_sym
-      raise UnknownMessage, "unknown message #{message_name.inspect}" unless actor_class.definition.messages.key?(message_symbol)
+      operation_symbol = operation.to_sym
+      raise UnknownMessage, "unknown operation #{operation.inspect}" unless actor_class.definition.messages.key?(operation_symbol)
 
       authorize!(
-        SolidObjects.configuration.authorize_message,
-        reference,
-        message_name,
-        arguments,
+        hook: SolidObjects.configuration.authorize_message,
+        reference:,
+        operation:,
+        arguments:,
         authorization_context:
       )
       mailbox.enqueue(
-        reference,
-        message_name,
-        arguments,
-        kind: "async",
+        reference:,
+        operation:,
+        arguments:,
+        delivery_mode: "async",
         available_at:,
         idempotency_key:
       )
     end
 
-    # @rbs (Reference, Symbol | String, Hash[Symbol | String, untyped], timeout: Numeric, ?idempotency_key: String?, ?authorization_context: untyped) -> untyped
-    def sync(reference, message_name, arguments, timeout:, idempotency_key: nil, authorization_context: nil)
+    # @rbs (reference: Reference, operation: Symbol | String, arguments: Hash[Symbol | String, untyped], timeout: Numeric, ?idempotency_key: String?, ?authorization_context: untyped) -> untyped
+    def sync(reference:, operation:, arguments:, timeout:, idempotency_key: nil, authorization_context: nil)
       actor_class = SolidObjects.registry.fetch(reference.actor_type)
-      message_symbol = message_name.to_sym
-      query = actor_class.definition.queries.key?(message_symbol)
-      actor_message = actor_class.definition.messages.key?(message_symbol)
-      raise UnknownMessage, "unknown message #{message_name.inspect}" unless query || actor_message
+      operation_symbol = operation.to_sym
+      query = actor_class.definition.queries.key?(operation_symbol)
+      actor_message = actor_class.definition.messages.key?(operation_symbol)
+      raise UnknownMessage, "unknown operation #{operation.inspect}" unless query || actor_message
 
       authorize!(
-        query ? SolidObjects.configuration.authorize_query : SolidObjects.configuration.authorize_message,
-        reference,
-        message_name,
-        arguments,
+        hook: query ? SolidObjects.configuration.authorize_query : SolidObjects.configuration.authorize_message,
+        reference:,
+        operation:,
+        arguments:,
         authorization_context:
       )
-      reject_sync_inside_transaction!(reference, message_name)
+      reject_sync_inside_transaction!(reference, operation)
       SyncDeadline.with(timeout:) do
         message_reference = enqueue_sync(
-          reference,
-          message_name,
-          arguments,
+          reference:,
+          operation:,
+          arguments:,
           idempotency_key:,
           timeout:
         )
@@ -75,19 +75,19 @@ module SolidObjects
           actor_id: message.actor_id
         )
         actor_class = SolidObjects.registry.fetch(reference.actor_type)
-        query = actor_class.definition.queries.key?(message.message_name.to_sym)
-        actor_message = actor_class.definition.messages.key?(message.message_name.to_sym)
+        query = actor_class.definition.queries.key?(message.operation.to_sym)
+        actor_message = actor_class.definition.messages.key?(message.operation.to_sym)
         unless query || actor_message
-          raise UnknownMessage, "unknown message #{message.message_name.inspect}"
+          raise UnknownMessage, "unknown operation #{message.operation.inspect}"
         end
         authorize!(
-          query ? SolidObjects.configuration.authorize_query : SolidObjects.configuration.authorize_message,
-          reference,
-          message.message_name,
-          message.arguments,
+          hook: query ? SolidObjects.configuration.authorize_query : SolidObjects.configuration.authorize_message,
+          reference:,
+          operation: message.operation,
+          arguments: message.arguments,
           authorization_context:
         )
-        reject_sync_inside_transaction!(reference, message.message_name)
+        reject_sync_inside_transaction!(reference, message.operation)
         SynchronousInvocation.new.call(message_reference, timeout:)
       end
     rescue DatabaseDeadlineExceeded
@@ -98,10 +98,10 @@ module SolidObjects
     def snapshot(reference, authorization_context: nil)
       SolidObjects.registry.fetch(reference.actor_type)
       authorize!(
-        SolidObjects.configuration.authorize_query,
-        reference,
-        "__snapshot__",
-        {},
+        hook: SolidObjects.configuration.authorize_query,
+        reference:,
+        operation: "__snapshot__",
+        arguments: {},
         authorization_context:
       )
       StateSnapshot.new(reference)
@@ -140,13 +140,13 @@ module SolidObjects
 
     attr_reader :mailbox
 
-    # @rbs (Reference, Symbol | String, Hash[Symbol | String, untyped], idempotency_key: String?, timeout: Numeric) -> MessageReference
-    def enqueue_sync(reference, message_name, arguments, idempotency_key:, timeout:)
+    # @rbs (reference: Reference, operation: Symbol | String, arguments: Hash[Symbol | String, untyped], idempotency_key: String?, timeout: Numeric) -> MessageReference
+    def enqueue_sync(reference:, operation:, arguments:, idempotency_key:, timeout:)
       mailbox.enqueue(
-        reference,
-        message_name,
-        arguments,
-        kind: "sync",
+        reference:,
+        operation:,
+        arguments:,
+        delivery_mode: "sync",
         idempotency_key:
       )
     rescue DatabaseDeadlineExceeded
@@ -154,13 +154,13 @@ module SolidObjects
         :"sync.enqueue_timeout",
         actor_type: reference.actor_type,
         actor_id: reference.actor_id,
-        message_name: message_name.to_s
+        operation: operation.to_s
       )
       raise SyncEnqueueTimeout.new(
         timeout:,
         actor_type: reference.actor_type,
         actor_id: reference.actor_id,
-        message_name: message_name.to_s
+        operation: operation.to_s
       )
     end
 
@@ -176,28 +176,28 @@ module SolidObjects
     end
 
     # @rbs (Reference, Symbol | String) -> void
-    def reject_sync_inside_transaction!(reference, message_name)
+    def reject_sync_inside_transaction!(reference, operation)
       return unless SolidObjects::Record.connection.transaction_open?
 
       SolidObjects.instrument(
         :"sync.transaction_rejected",
         actor_type: reference.actor_type,
         actor_id: reference.actor_id,
-        message_name: message_name.to_s
+        operation: operation.to_s
       )
       raise SyncInsideTransaction.new(
         actor_type: reference.actor_type,
         actor_id: reference.actor_id,
-        message_name: message_name.to_s
+        operation: operation.to_s
       )
     end
 
-    # @rbs (Proc, Reference, Symbol | String, Hash[Symbol | String, untyped], authorization_context: untyped) -> void
-    def authorize!(hook, reference, message_name, arguments, authorization_context:)
+    # @rbs (hook: Proc, reference: Reference, operation: Symbol | String, arguments: Hash[Symbol | String, untyped], authorization_context: untyped) -> void
+    def authorize!(hook:, reference:, operation:, arguments:, authorization_context:)
       authorized = hook.call(
         actor_type: reference.actor_type,
         actor_id: reference.actor_id,
-        message_name: message_name.to_s,
+        operation: operation.to_s,
         arguments:,
         authorization_context:
       )