solid_objects 0.14.3 → 0.14.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0c919699e07e7e1bd517a9fe0fa748558262c0cfe8483bcb992f8b85f65cb857
-  data.tar.gz: 30a29702722638f5168664ecbb69f174564419f7308cc7596d71e9066baa2e76
+  metadata.gz: 32207ee5017c24fa87258061048c532532bcf599d46357ce8da4deef8cb0c93e
+  data.tar.gz: d5594c50173f64f96303e91b0bc0b0659335d42b0d16b4df1e6f618ad98041fc
 SHA512:
-  metadata.gz: b8eee4e1bd40b39d67c3a74b2860a0f874336285d7291dcc740b578f8b4a8fedd3d1323e716c47df71f3615faef832519cbd3541f505f9e0c00b413f01a9e9e5
-  data.tar.gz: 2b808b25de0a30d05da80b24451f1c12139c3be6bf90f4fb760f754d42b775e22cb60339e75ec8c750f341f89e6f50cbb05f809d6cea936070183a0b2cb8a3e8
+  metadata.gz: 6578fe32fed59a2c8fc6f4209244de1d33793561af20b258d96c8bd7c5cd78e7203fa08ebaea4a2c8315c89980bf4033852d00c3f4cadad3a6986c766dea7dad
+  data.tar.gz: ec2db7a0481f6075ef9e1565a47f972bc41f6d464b65a7700139b4209636e079a254454007857ce7988fb1d01b745277a71a737d8f3e49f340e768106b511c38

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 0.14.4 - 2026-08-30
+
+- Reuse the encoding the after image already built. `State#to_h` copies the
+  state by encoding it and parsing the result, then threw the encoded string
+  away, and `complete` normalized and encoded the same hash a second time to
+  measure it. `to_h_with_byte_size` returns the copy with the size of the
+  encoding that produced it, so a committed turn now traverses the state twice
+  rather than three times and encodes it twice rather than three times.
+  Measured on SQLite against 0.14.3, committed throughput rises 5.3% at 13 KB
+  of state, 16.1% at 116 KB, and 12.0% at 1 MB. `docs/benchmarks.md` holds the
+  numbers. `solid-objects-js` already measured the string it commits; this
+  brings the gem to the same shape.
+- Add `Serialization.deep_copy_with_byte_size`, which returns a deep copy
+  beside the size of its encoded form. `deep_copy` now calls it, so both
+  encode once.
+- Enforce `max_state_bytes` against the size the after image reports rather
+  than by encoding the state again. The turn still fails with
+  `PayloadTooLarge` before it opens its commit transaction, which a test now
+  covers end to end.
+
 ## 0.14.3 - 2026-08-29
 
 - Cut one of the three full state copies a committed turn made. The executor

data/docs/benchmarks.md

@@ -142,6 +142,22 @@ used to do, so part of the saving pays for that check. The gain grows with the
 state, because the database write dominates a small turn. The empty-state row
 sits inside run-to-run variance.
 
+`0.14.4` removed the traversal that remained. Copying the state encodes it and
+parses the result, and the commit then normalized and encoded the same hash
+again to measure it. The copy now reports the size of the encoding that
+produced it. Measured the same way, against the released `0.14.3` tree:
+
+| Committed state | 0.14.3 | 0.14.4 | Change |
+| ---: | ---: | ---: | ---: |
+| 23 bytes | 1,251.2 messages/s | 1,242.8 messages/s | -0.7% |
+| 13,662 bytes | 612.0 messages/s | 644.7 messages/s | +5.3% |
+| 118,786 bytes | 171.9 messages/s | 199.6 messages/s | +16.1% |
+| 1,026,356 bytes | 23.4 messages/s | 26.2 messages/s | +12.0% |
+
+A committed turn now traverses the state twice and encodes it twice, against
+three of each before. The empty-state row again sits inside run-to-run
+variance.
+
 The curve matters more than the change. Throughput falls about 28 times between
 13 KB and 1 MB of state, and about 53 times between an empty state and 1 MB.
 The `max_state_bytes` default of 5 MB is therefore a limit rather than an

data/lib/solid_objects/executor.rb

@@ -26,13 +26,13 @@ module SolidObjects
       SolidObjects.instrument(:"message.started", **instrumentation_payload)
       result = invoke_actor(message_context)
       observable_changes = changed_observables(observables_before, actor.observable_values)
-      state_after = actor.state.to_h
-      ensure_query_did_not_mutate_state!(state_before, state_after)
+      state_after = actor.state.to_h_with_byte_size
+      ensure_query_did_not_mutate_state!(state_before, state_after.value)
       complete(
         result,
         observable_changes,
         state_after:,
-        state_changed: state_after != state_before
+        state_changed: state_after.value != state_before
       )
       true
     rescue LostActivation
@@ -81,12 +81,9 @@ module SolidObjects
       end
     end
 
-    # @rbs (untyped, Hash[String, untyped], state_after: Hash[String, untyped], state_changed: bool) -> void
+    # @rbs (untyped, Hash[String, untyped], state_after: Serialization::Dumped, state_changed: bool) -> void
     def complete(result, observable_changes, state_after:, state_changed:)
-      dumped_state = Serialization.dump_with_byte_size(
-        state_after,
-        max_bytes: SolidObjects.configuration.max_state_bytes
-      )
+      ensure_state_fits!(state_after.byte_size)
       serialized_result = Serialization.dump(
         (message.delivery_mode == "sync") ? result : nil,
         max_bytes: SolidObjects.configuration.max_result_bytes
@@ -108,7 +105,7 @@ module SolidObjects
         locked_message = Message.lock.find(message.id)
         execute_commit_actions(commit_action_intents)
         instance.update!(
-          state: dumped_state.value,
+          state: state_after.value,
           state_version: actor.class.state_version,
           state_revision: locked_message.sequence,
           last_used_at: SolidObjects.database_adapter.database_now
@@ -154,11 +151,19 @@ module SolidObjects
           actor_id: message.actor_id
         )
       end
-      report_large_state(dumped_state.byte_size)
+      report_large_state(state_after.byte_size)
       SolidObjects.instrument_after_commit(:"message.completed", **instrumentation_payload)
       SolidObjects.wake_up.signal
     end
 
+    # @rbs (Integer) -> void
+    def ensure_state_fits!(byte_size)
+      max_bytes = SolidObjects.configuration.max_state_bytes
+      return if byte_size <= max_bytes
+
+      raise PayloadTooLarge, "serialized value exceeds #{max_bytes} bytes"
+    end
+
     # @rbs (Integer) -> void
     def report_large_state(byte_count)
       threshold = SolidObjects.configuration.warn_state_bytes

data/lib/solid_objects/serialization.rb

@@ -37,7 +37,14 @@ module SolidObjects
 
       # @rbs (untyped) -> untyped
       def deep_copy(value)
-        JSON.parse(JSON.generate(normalize(value), max_nesting: MAX_NESTING))
+        deep_copy_with_byte_size(value).value
+      end
+
+      # @rbs (untyped) -> Dumped
+      def deep_copy_with_byte_size(value)
+        encoded = JSON.generate(normalize(value), max_nesting: MAX_NESTING)
+
+        Dumped.new(value: JSON.parse(encoded), byte_size: encoded.bytesize)
       rescue JSON::GeneratorError, JSON::ParserError, EncodingError => error
         raise InvalidPayload, error.message
       end

data/lib/solid_objects/state.rb

@@ -52,6 +52,11 @@ module SolidObjects
       Serialization.deep_copy(data)
     end
 
+    # @rbs () -> Serialization::Dumped
+    def to_h_with_byte_size
+      Serialization.deep_copy_with_byte_size(data)
+    end
+
     # @rbs (Symbol | String) -> untyped
     def fetch(name)
       key = name.to_s

data/lib/solid_objects/version.rb

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

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

@@ -30,8 +30,11 @@ module SolidObjects
     # @rbs (Hash[String, untyped], Hash[String, untyped]) -> Hash[String, untyped]
     def changed_observables: (Hash[String, untyped], Hash[String, untyped]) -> Hash[String, untyped]
 
-    # @rbs (untyped, Hash[String, untyped], state_after: Hash[String, untyped], state_changed: bool) -> void
-    def complete: (untyped, Hash[String, untyped], state_after: Hash[String, untyped], state_changed: bool) -> void
+    # @rbs (untyped, Hash[String, untyped], state_after: Serialization::Dumped, state_changed: bool) -> void
+    def complete: (untyped, Hash[String, untyped], state_after: Serialization::Dumped, state_changed: bool) -> void
+
+    # @rbs (Integer) -> void
+    def ensure_state_fits!: (Integer) -> void
 
     # @rbs (Integer) -> void
     def report_large_state: (Integer) -> void

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

@@ -29,6 +29,9 @@ module SolidObjects
     # @rbs (untyped) -> untyped
     def self.deep_copy: (untyped) -> untyped
 
+    # @rbs (untyped) -> Dumped
+    def self.deep_copy_with_byte_size: (untyped) -> Dumped
+
     # @rbs (untyped) -> untyped
     def self.readonly_copy: (untyped) -> untyped
 

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

@@ -45,6 +45,9 @@ module SolidObjects
     # @rbs () -> Hash[String, untyped]
     def to_h: () -> Hash[String, untyped]
 
+    # @rbs () -> Serialization::Dumped
+    def to_h_with_byte_size: () -> Serialization::Dumped
+
     # @rbs (Symbol | String) -> untyped
     def fetch: (Symbol | String) -> untyped
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: solid_objects
 version: !ruby/object:Gem::Version
-  version: 0.14.3
+  version: 0.14.4
 platform: ruby
 authors:
 - Lucas Carlson
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-08-29 00:00:00.000000000 Z
+date: 2026-08-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actioncable