solid_objects 0.14.5 → 0.14.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 45c9deb9d06f62e056668c5d3b547786ba69f9d866c302d850650d4ddeac7f9d
-  data.tar.gz: be67022b7559e87fa48adc91bc09466c005a77345e1631405cd4be76a038e8b5
+  metadata.gz: d36e77947a8de94216c9174cc3a34a878803bdf242efa0b10f6067d48b4e7cda
+  data.tar.gz: 178955e77093552df5569ee5c0badfb6035a51a479c7bcfbd1025465ac5947a4
 SHA512:
-  metadata.gz: 43ad462709bbb061bc9aef103ce4bed2b9f5432c2efd507a743ccbdd33c255c7c4c8540d8d203baef62ef1c552ffd8e6978403c83a400fa99329be9cafbc44ed
-  data.tar.gz: 909192b9a0ca8674439e4ade94c09b6d0cd03b6cddc1082d2f55d02e0de41b27b64688bd1cb8c8af77febb5dd3a78241b656fa8d77a12942b3e1678b61450e37
+  metadata.gz: 491698862debab8266650dbdc21a86561d3fa7dd51764edd469a7b5173a1b2a24a2542d39a584796d3433a2bc66794d7d5251ebfe73d7c991d539f2a4c92d287
+  data.tar.gz: 705ce841595e49cbc892535afd15fb96b8ac4134bb01a1c92de8d12061a6fe5717b745d989decf82fb1c25a19966b9e50a88afb30a1426c23055e1333c00f2cc

data/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 0.14.7 - 2026-09-14
+
+- Publish RBS contracts for effect callback envelopes and Ruby error summaries.
+  Check the runtime constructors and packaged consumer signatures strictly,
+  preserving ordinary hashes, keyword callbacks, serialization, and retries.
+- Add optional actor-specific RBS generation for staged schedule/transmit calls
+  and effect callback names. Reuse application-declared operation argument types
+  without changing Ruby dispatch, runtime validation, or global effect registries.
+
+## 0.14.6 - 2026-09-12
+
+- Preserve committed turns when an Active Record after-commit callback raises.
+  Caller assistance and workers expose the original callback exception without
+  restoring obsolete state, retrying/rejecting the completed message, or
+  masking the error as a missing claim. Track actual SQL commitment before
+  SQLite retries and deadline translation; retain pre-commit rollback, retry,
+  and domain-rejection behavior.
+
 ## 0.14.5 - 2026-09-03
 
 - Split broadcast claiming into separate pending and stale-processing probes,

data/README.md

@@ -110,15 +110,13 @@ bundle exec solid_objects start
 ```
 
 Stop that process before the deadline and restart it afterwards. The reminder
-is still in the Rails database and runs when the process returns. We have given
-`self.available += 1` a supervisor and excellent posture.
+is still in the Rails database and runs when the process returns. The reminder survived the restart.
 
 ## Why this exists
 
 The handwritten Rails version usually starts with `with_lock`. Then it gains an
 `expires_at` column, a cron job, an Active Job retry policy, and an Action Cable
-broadcast that must agree with the write. A small invariant has become a rich
-tapestry of callbacks and scheduled cleanup.
+broadcast that must agree with the write. A small invariant has spread across callbacks and scheduled cleanup.
 
 This is complicated, hard to test, fragile and unnecessary.
 
@@ -133,14 +131,12 @@ PostgreSQL, or MySQL. Redis and a separate actor service are not required.
 - Account, device, assessment, and approval workflows that survive deploys.
 - Reactive ERB views that must follow committed actor revisions.
 
-Different identities can run concurrently. Put the whole application behind
-one actor ID and Rails will faithfully operate your new bottleneck.
+Different identities can run concurrently. One actor ID for the whole application is a bottleneck.
 
 ## When a transaction is better
 
 Often. If the entire invariant fits inside one request, use `with_lock`, a
-database constraint, or a short transaction. A row lock does not need a
-personal brand, and it is usually the clearest answer.
+database constraint, or a short transaction. A row lock is usually the clearest answer.
 
 Use Solid Objects when work must happen later, survive a restart, or stay
 ordered across several requests or jobs. A plain counter remains one line of
@@ -171,15 +167,13 @@ Exactly once is not hiding in a more advanced configuration. Read the
 - [Detailed documentation](docs/)
 
 The dashboard, benchmarks, migration cookbook, schema, and exhaustive API
-explanations remain in `docs/`. The README is stopping before it develops a
-robust interplay with its own table of contents.
+explanations remain in `docs/`. The README stops here.
 
 ## Status and license
 
 Solid Objects Ruby is a pre-1.0 early release. Its correctness core is tested
 against SQLite, PostgreSQL, and MySQL, but the project makes no production-ready
-claim. That requires more hardening and operational soak evidence. Pre-1.0 is
-not decorative punctuation.
+claim. That requires more hardening and operational soak evidence. Expect breaking changes.
 
 Solid Objects is released under the [MIT License](MIT-LICENSE). It is an
 independent project and is not affiliated with, sponsored by, or endorsed by

data/Rakefile

@@ -14,7 +14,7 @@ task :rbs do
   FileUtils.rm_rf(File.expand_path("sig/generated", __dir__))
   sh "bundle exec rbs-inline --base lib --base app --output sig/generated lib app"
   FileUtils.rm_f(File.expand_path("sig/generated/lib/generators/solid_objects/templates/solid_objects.rbs", __dir__))
-  sh "bundle exec rbs -I sig/generated -I sig/support validate"
+  sh "bundle exec rbs -I sig/generated -I sig/support -I sig/public validate"
 end
 
 desc "Run Standard Ruby"

data/docs/architecture.md

@@ -314,9 +314,30 @@ Any lease or message predicate failure raises `LostActivation` and rolls back ev
 
 The state version can advance because of state migration even when the message itself makes no state change.
 
+Active Record may raise from an application `after_commit` callback while the
+transaction call unwinds, after SQL has committed. The adapter retains the
+actual transaction object and checks its fully committed state before any
+deadline conversion or SQLite retry. Reaching the end of the block, releasing
+a savepoint, or observing an in-memory message update is not proof of SQL
+commitment. A failing `before_commit` callback follows the rollback path.
+
+An internal `CommittedTransactionError` carries the original error through
+executor, SQLite retry, and coordination rescue handlers. The synchronous
+invocation and worker boundaries re-raise the original exception with its
+original backtrace and cause. The wrapper prevents a callback's `Rejected`,
+`LostActivation`, or database error from being mistaken for a pre-commit
+outcome. It is not a durable message error or a new delivery mechanism.
+
+After commitment, actor state, application writes, message completion/result,
+and outboxes remain durable. The executor preserves the committed activation
+state and does not retry, reject, or dead-letter that turn. Caller assistance
+still deactivates and releases its lease during cleanup; cached worker state
+can process later messages. A worker running its continuous loop exposes the
+error and runs its existing shutdown cleanup.
+
 ## Failure path
 
-Actor exceptions roll back all in-memory changes by restoring the pre-turn state. A separate short transaction conditionally owned by the current generation:
+Before commitment, actor and commit-action exceptions roll back all in-memory changes by restoring the pre-turn state. A separate short transaction conditionally owned by the current generation:
 
 - Stores a sanitized error
 - Deletes claimed membership
@@ -403,9 +424,15 @@ outer commit, and callers timing out on work they indirectly block.
 waiting and immediately returns a `MessageReference`. Runtime workers process
 it normally.
 
+An executing caller receives an inline after-commit callback error even though
+the turn committed. An independently waiting caller observes the durable
+result and may return before that callback raises in the worker. Completed
+history is not changed retroactively; callback failures must be observed in
+the executing process. Later Rails callbacks may not run after one raises.
+
 ## Domain rejection
 
-Actor code can call `reject` for a validation or business-rule outcome that
+Before commitment, actor code can call `reject` for a validation or business-rule outcome that
 must not retry. The executor restores pre-turn state, discards staged intents,
 stores the structured rejection, completes the claimed membership, and
 continues with the next sequence in one fenced transaction. Synchronous callers
@@ -416,6 +443,10 @@ a dead letter.
 
 `emit` creates a staged effect:
 
+Typed applications can generate [actor-specific RBS signatures](development.md#actor-specific-dispatch-signatures)
+to check callback names and staged `schedule`/`transmit` calls without changing
+their Ruby syntax. Effect and commit-action registry names remain independent.
+
 ```ruby
 emit(
   :charge_payment,
@@ -456,6 +487,50 @@ and `result:`. A failure callback receives `effect_id:`, `arguments:`, and
 `error:`, so an actor can correlate concurrent effects without storing a
 separate callback ledger.
 
+### Typing your on_failure handler
+
+The gem ships `SolidObjects::effect_error`,
+`SolidObjects::effect_failure_payload[Arguments]`, and
+`SolidObjects::effect_success_payload[Arguments, Result]` as public RBS aliases.
+They describe the existing string-keyed hashes; they are not Ruby wrapper classes.
+See [signature loading](development.md#public-effect-payload-signatures) for Steep setup.
+
+For an actor with `generation` and `status` attributes, declare the callback keywords
+in the application's RBS:
+
+```rbs
+class ChatRun < SolidObjects::Actor
+  type run_arguments = { "generation" => Integer }
+  def fail_turn: (effect_id: String, arguments: run_arguments, error: SolidObjects::effect_error) -> void
+end
+```
+
+```ruby
+def fail_turn(effect_id:, arguments:, error:)
+  return unless arguments["generation"] == generation
+
+  self.status = "failed"
+end
+```
+
+Record access with `arguments["generation"]` retains its declared `Integer` type.
+The callback receives top-level keywords, while nested arguments and error keys
+remain strings. The failure envelope requires `"effect_id"`, `"arguments"`, and
+`"error"`; the success envelope replaces `"error"` with `"result"`. Empty original
+arguments remain `{}`, and a success result may be `nil` or any supported JSON value.
+Ruby errors contain `"class"` (`String?`, including anonymous exception classes),
+`"message"` (`String`, limited to 8,192 bytes), and `"backtrace"` (`Array[String]`,
+limited to 50 entries and possibly empty).
+
+Applications supply the generic argument/result types to describe their serialized
+JSON values. These aliases do not infer or validate independently registered effect
+handlers. Their type parameters are deliberately unconstrained: Ruby serialization
+accepts and normalizes values such as symbols, and RBS cannot express that conversion
+as a generic bound. The constructors and consumer fixtures are checked with strict
+Steep diagnostics. JavaScript exposes equivalent contracts with its existing
+camelCase ID and `{ name, message }` error shape in
+[solid-objects-js#47](https://github.com/cardmagic/solid-objects-js/issues/47).
+
 A commit action is registered the same way and runs inside the short fenced
 transaction:
 

data/docs/correctness.md

@@ -125,6 +125,29 @@ it is available only when Solid Objects and `ActiveRecord::Base` share one
 connection pool. Commit actions must contain only bounded database work.
 External I/O belongs in the effect outbox.
 
+### Errors after SQL commit
+
+Active Record `after_commit` callbacks registered by commit actions run after
+SQL commitment. If one raises, the application writes, actor state, message
+result/completion, and claimed-membership deletion remain committed. The
+executor does not restore the pre-turn snapshot, retry the business action,
+reject the message, or create a dead letter. A `before_commit` callback can
+still roll back everything even after the fenced transaction block finishes.
+
+The executing synchronous caller or `Worker#run_once` receives the original
+callback exception, including its identity, backtrace, and cause. This also
+applies when the callback raises `Rejected`, `LostActivation`, or a database
+deadline/lock error: its class does not change a committed turn into a failed
+one. Synchronous cleanup releases the activation; a worker retains the
+committed state until normal deactivation or shutdown, so later messages can
+continue from that state.
+
+A separate waiting caller can observe the durable result before the callback
+finishes. There is no retroactive failure delivery or durable callback-error
+result. Inspect and report errors in the executing process. Rails may skip
+later callbacks when one raises; these callbacks are not a durable delivery
+mechanism. Use an idempotent effect for work that needs independent retries.
+
 ## Reactive components
 
 A successful fenced turn advances `instances.state_revision` to that message's
@@ -205,7 +228,7 @@ wakes the caller, and raises `SolidObjects::ActorDestroyed`.
 
 ## Domain rejection
 
-`reject` is a terminal domain outcome, not an infrastructure failure. It rolls
+`reject` before commitment is a terminal domain outcome, not an infrastructure failure. It rolls
 back in-memory state and staged intents, stores a structured rejection on the
 message, removes claimed membership, and lets the next sequence run. It is
 never retried or dead-lettered. The synchronous caller receives

data/docs/development.md

@@ -103,6 +103,116 @@ bundle exec rake rbs
 
 This follows the inline convention used by `cardmagic/classifier`.
 
+### Public effect payload signatures
+
+The packaged `sig/public` directory owns the reusable effect payload aliases and
+survives `rake rbs` regeneration. A host application's Steep target can load the
+installed gem's complete signature tree alongside its own signatures:
+
+```ruby
+target :app do
+  library "solid_objects"
+  signature "sig"
+  check "app/actors"
+  configure_code_diagnostics(Diagnostic::Ruby.strict)
+end
+```
+
+This requires no internal runtime imports. See the
+[typed callback example](architecture.md#typing-your-on_failure-handler).
+The gem's strict payload target checks the actual constructors; its packaged
+consumer test also verifies that missing keys and incorrect field types fail.
+
+### Actor-specific dispatch signatures
+
+Typed applications can opt into `SolidObjects::ActorSignatures` to check ordinary
+`schedule`, `transmit`, and effect callback names inside actor methods. Add `rbs`
+and `steep` to the application's development dependencies. This tool is loaded
+explicitly and is not required by workers or ordinary Ruby applications.
+
+Declare application operation types first, including inherited operations and
+block-defined `message` operations. Inline RBS can generate this input, or keep
+handwritten declarations in a separate directory such as `sig/actors`:
+
+```rbs
+class ChatRun < SolidObjects::Actor
+  def recover_if_stuck: (generation: Integer) -> nil
+  def fail_turn: (effect_id: String, arguments: Hash[String, untyped], error: Hash[String, untyped]) -> nil
+  def start: () -> nil
+end
+```
+
+After loading the application's actor classes, generate a separate output file:
+
+```ruby
+require "solid_objects/actor_signatures"
+
+Rails.application.reloader.wrap do
+  signatures = SolidObjects::ActorSignatures.generate(
+    actors: [ChatRun],
+    signatures: [Rails.root.join("sig/actors").to_s]
+  )
+  FileUtils.mkdir_p(Rails.root.join("sig/generated"))
+  File.write(Rails.root.join("sig/generated/solid_objects.rbs"), signatures)
+end
+```
+
+Run that script with `bin/rails runner` during development or CI. Outside Rails,
+require the actor definitions and call `generate` directly. The generator returns
+a string and does not write files, execute actor operations, start workers, or run
+migrations. Rails boot follows the application's normal loading configuration;
+the explicit actor list resolves its autoloaded classes within the reloader boundary.
+Keep generated output out of the input signature paths, and regenerate after a
+message is renamed or removed. Output is deterministic; handwritten signatures
+remain separate.
+
+Load the gem and both application signature directories in `Steepfile`:
+
+```ruby
+target :actors do
+  library "solid_objects"
+  signature "sig/actors"
+  signature "sig/generated"
+  check "app/actors"
+  configure_code_diagnostics(Diagnostic::Ruby.strict)
+end
+```
+
+The usual Ruby code now passes Steep without a dispatcher cast:
+
+```ruby
+schedule(at: Time.now, key: "watchdog").recover_if_stuck(generation: 1)
+transmit.recover_if_stuck(generation: 1)
+emit :run_model, generation: 1, on_failure: :fail_turn
+```
+
+Misspelled operations/callbacks, queries, attributes, private methods, infrastructure
+methods, and incorrect keyword arguments fail the strict check. Both string and
+symbol callback literals work. Staging returns `nil` even when an operation's own
+return type differs. Effect and commit-action names remain global registry names;
+registry contract inference is separate work.
+
+Reflection supplies message names only. Values come from declared RBS signatures;
+missing signatures and positional/block arguments are rejected. Block-defined
+messages require explicit method declarations in RBS; annotate their block-local
+values separately when checking the block body. Generic actor classes currently
+require application-owned dispatcher signatures. The generator preserves method
+overloads and method type parameters.
+
+Deliberately dynamic names can use Ruby's explicit dynamic dispatch:
+
+```ruby
+schedule(at: Time.now).public_send(operation_name, generation: generation)
+public_send(:emit, :run_model, on_failure: callback_name, generation: generation)
+```
+
+Those calls opt out of name/argument checking and retain the existing runtime
+validation. Ordinary calls on the generated dispatcher have no string-name fallback.
+`send_to`, `Reference#async`, direct calls, and queries retain their existing
+signatures and runtime behavior; this generator does not provide complete reference
+typing or Sorbet/Tapioca actor-specific RBI generation. The corresponding TypeScript
+work is tracked in [solid-objects-js#46](https://github.com/cardmagic/solid-objects-js/issues/46).
+
 ## Formatting and security
 
 ```bash

data/docs/operations.md

@@ -69,6 +69,12 @@ Rails schema migrations and actor state migrations are separate concerns.
 
 ### Host application tooling
 
+RBS/Steep applications can generate
+[actor-specific dispatch signatures](development.md#actor-specific-dispatch-signatures)
+for reminders, transmit calls, and effect callback names. This is optional development
+tooling; generated signatures do not change runtime dispatch. The generator does
+not supply equivalent Sorbet/Tapioca actor-specific types.
+
 Installed engine migrations are copied as
 `db/migrate/*_create_solid_objects_tables.solid_objects.rb`. If the host enables
 `Rails/CreateTableWithTimestamps`, exclude engine-owned migrations rather than

data/docs/reminders.md

@@ -39,6 +39,14 @@ raises, and nothing is logged except a `solid_objects.reminder.replaced` event.
 
 ## An alarm per item, with `key:`
 
+For watchdogs paired with an effect's give-up callback, see
+[typing your `on_failure` handler](architecture.md#typing-your-on_failure-handler)
+to retain the original argument types without repeating the error hash contract.
+
+For static checking of watchdog operation names and keyword arguments, opt into
+[actor-specific RBS signatures](development.md#actor-specific-dispatch-signatures).
+The Ruby `schedule(...).recover_if_stuck(generation: ...)` syntax stays the same.
+
 Pass `key:` when an actor is waiting on several things at once. The key is your
 own identifier for the item, and it names that item's alarm, so each item gets
 one:

data/docs/roadmap.md

@@ -14,6 +14,8 @@
   dead letters, and tail retry
 - Transactional effects with success/failure actor messages carrying the
   originally staged arguments for callback correlation
+- Public RBS effect success/failure envelopes and error records, checked against
+  the runtime constructors and a packaged consumer with strict Steep diagnostics
 - 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
@@ -65,6 +67,10 @@
   gem's dependencies
 - Inline RBS generation/validation, Steep, Standard Ruby, Solid Queue's exact
   RuboCop policy, and a warning-free Brakeman scan
+- Opt-in actor-specific RBS generation for schedule/transmit keyword arguments
+  and effect callback names, using application declarations and checked consumer
+  fixtures. Dynamic names remain an explicit escape hatch; complete reference
+  typing and actor-specific RBI generation are separate work
 - Compatibility CI across the supported span: Ruby 3.3, 3.4, and 4.0 against
   Rails 7.1, 7.2, 8.0, and 8.1, pinned through `RAILS_VERSION` so the advertised
   range is verified rather than assumed. The compatibility job runs SQLite only;

data/lib/solid_objects/actor_signatures.rb

@@ -0,0 +1,80 @@
+# rbs_inline: enabled
+
+require "solid_objects"
+require "rbs"
+require "pathname"
+
+module SolidObjects
+  class ActorSignatures
+    # @rbs (actors: Array[Class], signatures: Array[String]) -> String
+    def self.generate(actors:, signatures:)
+      new(signatures:).generate(actors:)
+    end
+
+    # @rbs @builder: untyped
+
+    # @rbs (signatures: Array[String]) -> void
+    def initialize(signatures:)
+      loader = RBS::EnvironmentLoader.new
+      loader.add(path: Pathname.new(File.expand_path("../../sig", __dir__)))
+      signatures.sort.each { |path| loader.add(path: Pathname.new(path)) }
+      environment = RBS::Environment.from_loader(loader).resolve_type_names
+      @builder = RBS::DefinitionBuilder.new(env: environment)
+    end
+
+    # @rbs (actors: Array[Class]) -> String
+    def generate(actors:)
+      actors.uniq.sort_by { |actor| actor.name.to_s }.map { |actor| actor_signature(actor) }.join("\n")
+    end
+
+    private
+
+    # @rbs (untyped) -> String
+    def actor_signature(actor)
+      unless actor < Actor && actor.name
+        raise ArgumentError, "actor signatures require named SolidObjects::Actor subclasses"
+      end
+
+      name = RBS::TypeName.parse("::#{actor.name}")
+      definition = @builder.build_instance(name)
+      if definition.type_params.any?
+        raise ArgumentError, "generic actor classes require application-owned dispatcher signatures"
+      end
+      messages = actor.definition.messages.keys.sort
+      methods = messages.map do |operation|
+        method = definition.methods[operation]
+        unless method && method.accessibility == :public
+          raise ArgumentError, "declare a public RBS signature for #{actor.name}##{operation}"
+        end
+        types = method.method_types.map { |type| staged_type(type, actor.name, operation).to_s }
+        "    def #{operation}: #{types.join("\n      | ")}"
+      end
+      callback_names = messages.flat_map { |operation| [ operation.inspect, operation.to_s.inspect ] }
+      callbacks = (callback_names + [ "nil" ]).join(" | ")
+      <<~RBS
+        class #{name}
+          interface _SolidObjectsOperations
+        #{methods.join("\n")}
+            def public_send: (Symbol | String, **untyped) -> nil
+          end
+
+          def schedule: (at: Time, ?every: Numeric?, ?missed: Symbol | String, ?key: (String | Symbol | Integer)?) -> #{name}::_SolidObjectsOperations
+          def transmit: () -> #{name}::_SolidObjectsOperations
+          def emit: (Symbol | String, ?on_success: (#{callbacks}), ?on_failure: (#{callbacks}), **untyped) -> nil
+        end
+      RBS
+    end
+
+    # @rbs (untyped, String, Symbol) -> untyped
+    def staged_type(method_type, actor_name, operation)
+      function = method_type.type
+      if !function.is_a?(RBS::Types::Function) || method_type.block ||
+          function.required_positionals.any? || function.optional_positionals.any? ||
+          function.rest_positionals || function.trailing_positionals.any?
+        raise ArgumentError, "#{actor_name}##{operation} must declare keyword-only arguments without a block"
+      end
+
+      method_type.update(type: function.update(return_type: RBS::Types::Bases::Nil.new(location: nil)))
+    end
+  end
+end

data/lib/solid_objects/database_adapter.rb

@@ -123,17 +123,21 @@ module SolidObjects
 
     # @rbs () { () -> untyped } -> untyped
     def transaction(&block)
+      active_transaction = nil
       raise DatabaseDeadlineExceeded, "synchronous invocation deadline expired" if SyncDeadline.expired?
 
       with_connection do |connection|
         with_transaction_deadline(connection) do
           connection.transaction(requires_new: true) do
+            active_transaction = connection.current_transaction
             configure_transaction_deadline(connection)
             with_transaction_clock { block.call }
           end
         end
       end
     rescue => error
+      raise CommittedTransactionError.new(error) if active_transaction&.state&.fully_committed?
+
       raise unless deadline_error?(error)
 
       raise DatabaseDeadlineExceeded,

data/lib/solid_objects/database_adapters/sqlite.rb

@@ -33,6 +33,8 @@ module SolidObjects
         attempts = 0
         begin
           yield
+        rescue CommittedTransactionError
+          raise
         rescue => error
           raise unless busy_error?(error)
 
@@ -53,6 +55,8 @@ module SolidObjects
         with_connection do |connection|
           with_transaction_deadline(connection) { yield }
         end
+      rescue CommittedTransactionError
+        raise
       rescue DatabaseDeadlineExceeded
         raise if SyncDeadline.expired?
 

data/lib/solid_objects/effect_executor.rb

@@ -184,11 +184,11 @@ module SolidObjects
           effect: locked_effect,
           operation: locked_effect.success_operation,
           outcome: "success",
-          arguments: {
-            "effect_id" => locked_effect.effect_id,
-            "arguments" => locked_effect.arguments,
-            "result" => serialized_result
-          }
+          arguments: EffectPayload.success(
+            effect_id: locked_effect.effect_id,
+            arguments: locked_effect.arguments,
+            result: serialized_result
+          )
         )
         locked_effect.update!(
           status: "completed",
@@ -216,21 +216,17 @@ module SolidObjects
         locked_effect = Effect.lock.find(effect.id)
         verify_claim!(locked_effect)
         dead = locked_effect.attempt_count >= locked_effect.max_attempts
-        error_details = {
-          "class" => error.class.name,
-          "message" => error.message.to_s.byteslice(0, 8_192),
-          "backtrace" => Array(error.backtrace).first(50)
-        }
+        error_details = EffectPayload.error(error)
         if dead
           result_message = enqueue_result_message(
             effect: locked_effect,
             operation: locked_effect.failure_operation,
             outcome: "failure",
-            arguments: {
-              "effect_id" => locked_effect.effect_id,
-              "arguments" => locked_effect.arguments,
-              "error" => error_details
-            }
+            arguments: EffectPayload.failure(
+              effect_id: locked_effect.effect_id,
+              arguments: locked_effect.arguments,
+              error: error_details
+            )
           )
         end
         locked_effect.update!(

data/lib/solid_objects/effect_payload.rb

@@ -0,0 +1,27 @@
+# rbs_inline: enabled
+
+module SolidObjects
+  module EffectPayload
+    class << self
+      # @rbs [Arguments, Result] (effect_id: String, arguments: Arguments, result: Result) -> effect_success_payload[Arguments, Result]
+      def success(effect_id:, arguments:, result:)
+        { "effect_id" => effect_id, "arguments" => arguments, "result" => result }
+      end
+
+      # @rbs [Arguments] (effect_id: String, arguments: Arguments, error: effect_error) -> effect_failure_payload[Arguments]
+      def failure(effect_id:, arguments:, error:)
+        { "effect_id" => effect_id, "arguments" => arguments, "error" => error }
+      end
+
+      # @rbs (Exception) -> effect_error
+      def error(exception)
+        message = exception.message.to_s.byteslice(0, 8_192) # : String
+        {
+          "class" => exception.class.name,
+          "message" => message,
+          "backtrace" => Array(exception.backtrace).first(50)
+        }
+      end
+    end
+  end
+end

data/lib/solid_objects/errors.rb

@@ -67,6 +67,23 @@ module SolidObjects
   class DatabaseDeadlineExceeded < Error
   end
 
+  class CommittedTransactionError < Error
+    # @rbs @original_error: StandardError
+
+    attr_reader :original_error
+
+    # @rbs (StandardError) -> void
+    def initialize(original_error)
+      @original_error = original_error
+      super(original_error.message)
+    end
+
+    # @rbs () -> bot
+    def reraise
+      raise original_error, cause: original_error.cause
+    end
+  end
+
   class SyncEnqueueTimeout < Error
     # @rbs @timeout: Numeric
     # @rbs @actor_type: String

data/lib/solid_objects/executor.rb

@@ -4,6 +4,7 @@ module SolidObjects
   class Executor
     # @rbs @activation: Activation
     # @rbs @message: Message
+    # @rbs @completion_transaction: untyped
 
     # @rbs (activation: Activation, message: Message) -> void
     def initialize(activation:, message:)
@@ -35,7 +36,7 @@ module SolidObjects
         state_changed: state_after.value != state_before
       )
       true
-    rescue LostActivation
+    rescue CommittedTransactionError, LostActivation
       raise
     rescue Rejected => rejection
       activation.restore_state(state_before) if state_before
@@ -96,6 +97,7 @@ module SolidObjects
       moved_reminders = []
 
       activation.lease.fenced_transaction do |instance|
+        @completion_transaction = Record.connection.current_transaction
         # A busy database makes the adapter retry this whole block, so an
         # attempt that was rolled back must not leave its work in the lists the
         # reporting below reads. Each attempt starts from empty.
@@ -154,6 +156,12 @@ module SolidObjects
       report_large_state(state_after.byte_size)
       SolidObjects.instrument_after_commit(:"message.completed", **instrumentation_payload)
       SolidObjects.wake_up.signal
+    rescue CommittedTransactionError
+      raise
+    rescue => error
+      raise unless @completion_transaction&.state&.fully_committed?
+
+      raise CommittedTransactionError.new(error)
     end
 
     # @rbs (Integer) -> void

data/lib/solid_objects/synchronous_invocation.rb

@@ -20,6 +20,8 @@ module SolidObjects
       SyncDeadline.with(timeout:) do
         call_before_deadline(message_reference, timeout:)
       end
+    rescue CommittedTransactionError => error
+      error.reraise
     rescue ActiveRecord::RecordNotFound
       raise ActorDestroyed, "actor was destroyed while waiting for its result"
     end

data/lib/solid_objects/version.rb

@@ -1,5 +1,5 @@
 # rbs_inline: enabled
 
 module SolidObjects
-  VERSION = "0.14.5"
+  VERSION = "0.14.7"
 end

data/lib/solid_objects/worker.rb

@@ -59,6 +59,8 @@ module SolidObjects
       ).around { activation.drain }
       release_activation(activation) if activation.pass_exhausted?
       processed
+    rescue CommittedTransactionError => error
+      error.reraise
     rescue ActorDestroyed
       release_activation(activation) if activation
       0

data/lib/solid_objects.rb

@@ -55,6 +55,7 @@ require "solid_objects/wake_up_adapters/redis"
 require "solid_objects/wake_up_adapters"
 require "solid_objects/polling_backoff"
 require "solid_objects/effect_registry"
+require "solid_objects/effect_payload"
 require "solid_objects/commit_action_registry"
 require "solid_objects/lease"
 require "solid_objects/lease_renewer"

data/sig/generated/lib/solid_objects/actor_signatures.rbs

@@ -0,0 +1,24 @@
+# Generated from lib/solid_objects/actor_signatures.rb with RBS::Inline
+
+module SolidObjects
+  class ActorSignatures
+    # @rbs (actors: Array[Class], signatures: Array[String]) -> String
+    def self.generate: (actors: Array[Class], signatures: Array[String]) -> String
+
+    @builder: untyped
+
+    # @rbs (signatures: Array[String]) -> void
+    def initialize: (signatures: Array[String]) -> void
+
+    # @rbs (actors: Array[Class]) -> String
+    def generate: (actors: Array[Class]) -> String
+
+    private
+
+    # @rbs (untyped) -> String
+    def actor_signature: (untyped) -> String
+
+    # @rbs (untyped, String, Symbol) -> untyped
+    def staged_type: (untyped, String, Symbol) -> untyped
+  end
+end

data/sig/generated/lib/solid_objects/effect_payload.rbs

@@ -0,0 +1,14 @@
+# Generated from lib/solid_objects/effect_payload.rb with RBS::Inline
+
+module SolidObjects
+  module EffectPayload
+    # @rbs [Arguments, Result] (effect_id: String, arguments: Arguments, result: Result) -> effect_success_payload[Arguments, Result]
+    def self.success: [Arguments, Result] (effect_id: String, arguments: Arguments, result: Result) -> effect_success_payload[Arguments, Result]
+
+    # @rbs [Arguments] (effect_id: String, arguments: Arguments, error: effect_error) -> effect_failure_payload[Arguments]
+    def self.failure: [Arguments] (effect_id: String, arguments: Arguments, error: effect_error) -> effect_failure_payload[Arguments]
+
+    # @rbs (Exception) -> effect_error
+    def self.error: (Exception) -> effect_error
+  end
+end

data/sig/generated/lib/solid_objects/errors.rbs

@@ -67,6 +67,18 @@ module SolidObjects
   class DatabaseDeadlineExceeded < Error
   end
 
+  class CommittedTransactionError < Error
+    @original_error: StandardError
+
+    attr_reader original_error: untyped
+
+    # @rbs (StandardError) -> void
+    def initialize: (StandardError) -> void
+
+    # @rbs () -> bot
+    def reraise: () -> bot
+  end
+
   class SyncEnqueueTimeout < Error
     @timeout: Numeric
 

data/sig/generated/lib/solid_objects/executor.rbs

@@ -2,6 +2,8 @@
 
 module SolidObjects
   class Executor
+    @completion_transaction: untyped
+
     @message: Message
 
     @activation: Activation

data/sig/public/effect_payload.rbs

@@ -0,0 +1,19 @@
+module SolidObjects
+  type effect_error = {
+    "class" => String?,
+    "message" => String,
+    "backtrace" => Array[String]
+  }
+
+  type effect_failure_payload[Arguments] = {
+    "effect_id" => String,
+    "arguments" => Arguments,
+    "error" => effect_error
+  }
+
+  type effect_success_payload[Arguments, Result] = {
+    "effect_id" => String,
+    "arguments" => Arguments,
+    "result" => Result
+  }
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: solid_objects
 version: !ruby/object:Gem::Version
-  version: 0.14.5
+  version: 0.14.7
 platform: ruby
 authors:
 - Lucas Carlson
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-09-03 00:00:00.000000000 Z
+date: 2026-09-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actioncable
@@ -389,6 +389,7 @@ files:
 - lib/solid_objects/actor_channel.rb
 - lib/solid_objects/actor_definition.rb
 - lib/solid_objects/actor_registry.rb
+- lib/solid_objects/actor_signatures.rb
 - lib/solid_objects/actor_snapshot.rb
 - lib/solid_objects/actor_view.rb
 - lib/solid_objects/administration.rb
@@ -416,6 +417,7 @@ files:
 - lib/solid_objects/doctor.rb
 - lib/solid_objects/dom_identity.rb
 - lib/solid_objects/effect_executor.rb
+- lib/solid_objects/effect_payload.rb
 - lib/solid_objects/effect_registry.rb
 - lib/solid_objects/engine.rb
 - lib/solid_objects/errors.rb
@@ -478,6 +480,7 @@ files:
 - sig/generated/lib/solid_objects/actor_channel.rbs
 - sig/generated/lib/solid_objects/actor_definition.rbs
 - sig/generated/lib/solid_objects/actor_registry.rbs
+- sig/generated/lib/solid_objects/actor_signatures.rbs
 - sig/generated/lib/solid_objects/actor_snapshot.rbs
 - sig/generated/lib/solid_objects/actor_view.rbs
 - sig/generated/lib/solid_objects/administration.rbs
@@ -505,6 +508,7 @@ files:
 - sig/generated/lib/solid_objects/doctor.rbs
 - sig/generated/lib/solid_objects/dom_identity.rbs
 - sig/generated/lib/solid_objects/effect_executor.rbs
+- sig/generated/lib/solid_objects/effect_payload.rbs
 - sig/generated/lib/solid_objects/effect_registry.rbs
 - sig/generated/lib/solid_objects/engine.rbs
 - sig/generated/lib/solid_objects/errors.rbs
@@ -561,6 +565,7 @@ files:
 - sig/generated/models/solid_objects/ready_message.rbs
 - sig/generated/models/solid_objects/record.rbs
 - sig/generated/models/solid_objects/reminder.rbs
+- sig/public/effect_payload.rbs
 - sig/support/framework.rbs
 - web/assets/javascripts/application.js
 - web/assets/javascripts/charts.js