solid_objects 0.7.1 → 0.7.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 75595f12197f05985076afb8974ec528b85914db25da49c29b342b9fc531ad97
-  data.tar.gz: d240311fe0bfbbd12386d582c4a8dcb560a2698385d65c1f0781340880cbd11c
+  metadata.gz: de78ca94f2c12e3c08d50c7b2512d6dbda67a47571540390c7494c6a828f1d35
+  data.tar.gz: b194c137ff3110cabb6cb2f7319819fdd64f314a9ae2113868438a89acce36b8
 SHA512:
-  metadata.gz: e303049a41809dca76e99ed3b035cde028817e2f0a6a7fadc1fd90f41bde9e108b83bc06247d596722c135ffad4b9b2fda9e5fb75277a89e837acc0c3ade9b25
-  data.tar.gz: 8f800ed5e80df86176ff1f7967da7f117363607c2993872670bfe0d85a0ece83db1eef8f1f4f72a74992182cae77f36bd80ea30ebc81b9c7a5bd03ba16a14785
+  metadata.gz: 78834ecb346469854b6d21d938fe3a6ed2689cd60cb037b22b3ce00025466c172ceb3dacdfcf94f88b0e0739e3dcac1c3e84896c6685bc4fe53d4db565ab8513
+  data.tar.gz: 31fbae44dce542e1fc07fe218bf504eb8627583ecc64895e8d86a5805340aeea47531b5f08a6e844809c31b513998c53c28b90993ae9cd40b864e868323eee27

data/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## 0.7.3 - 2026-08-09
+
+- Coordinate batched component refreshes by revision as well as scope and batch
+  name. Invalidations for one revision arrive as separate WebSocket messages, so
+  the microtask merge could not see them all, and each request aborted the one
+  before it. Only the last component updated. Same-revision requests now run
+  alongside each other and every frame is applied; only a strictly newer
+  revision supersedes an in-flight request. Frames already applied at a revision
+  are not applied twice.
+
+## 0.7.2 - 2026-08-09
+
+- Render batched component partials as HTML regardless of the request format.
+  The batch endpoint is requested with a JSON `Accept` header, so Rails looked
+  for JSON templates, raised `ActionView::MissingTemplate`, and the batch
+  returned 404 for applications whose components are ordinary
+  `.html.erb` partials. The outer response is still JSON. Single-component
+  refresh was never affected and is unchanged.
+- Pass `registrations:` to `component_authorization_context`: one registration
+  for a single refresh, all of them for a batch, so applications no longer have
+  to inspect `params[:tokens]`. Callbacks accepting only `controller:` keep
+  working unchanged.
+
 ## 0.7.1 - 2026-08-09
 
 - Retry a contended SQLite write outside a synchronous deadline. Asynchronous

data/app/assets/javascripts/solid_objects/component_batch_refresh.js

@@ -1,5 +1,7 @@
 const pendingBatches = new Map()
 const activeBatches = new Map()
+const appliedRevisions = new Map()
+let requestSequence = 0
 
 class SolidObjectsBatchRefreshElement extends HTMLElement {
   connectedCallback() {
@@ -34,18 +36,26 @@ class SolidObjectsBatchRefreshElement extends HTMLElement {
     pendingBatches.set(key, merged)
     queueMicrotask(() => {
       pendingBatches.delete(key)
-      requestBatch(group, batch, merged.sources)
+      requestBatch(group, batch, revision, merged.sources)
     })
     this.remove()
   }
 }
 
-async function requestBatch(group, batch, sources) {
-  const previous = activeBatches.get(group)
-  previous?.abort()
-
+// Invalidations for one revision arrive in separate WebSocket messages, so the
+// microtask merge cannot see them all. Requests are tracked per revision and a
+// request is only cancelled by a strictly newer one; same-revision requests run
+// alongside each other and every frame is applied.
+async function requestBatch(group, batch, revision, sources) {
+  const parsed = parseRevision(revision)
+  supersedeOlderRequests(group, parsed)
+
+  // Same-revision requests run concurrently, so each needs its own entry.
+  // Sharing one key per revision would leave all but the last untracked and
+  // therefore impossible to supersede.
+  const key = `${group}:${revision}:${(requestSequence += 1)}`
   const controller = new AbortController()
-  activeBatches.set(group, controller)
+  activeBatches.set(key, { controller, group, revision: parsed })
 
   try {
     const url = mergedUrl(sources)
@@ -68,10 +78,29 @@ async function requestBatch(group, batch, sources) {
   } catch (error) {
     if (error.name !== "AbortError") dispatchBatchError(batch, "request_failed")
   } finally {
-    if (activeBatches.get(group) === controller) activeBatches.delete(group)
+    if (activeBatches.get(key)?.controller === controller) activeBatches.delete(key)
   }
 }
 
+function supersedeOlderRequests(group, revision) {
+  if (!revision) return
+
+  activeBatches.forEach((entry, key) => {
+    if (entry.group !== group) return
+    if (!olderRevision(entry.revision, revision)) return
+
+    entry.controller.abort()
+    activeBatches.delete(key)
+  })
+}
+
+function olderRevision(candidate, current) {
+  if (!candidate || !current) return false
+
+  return candidate[0] < current[0] ||
+    (candidate[0] === current[0] && candidate[1] < current[1])
+}
+
 // Every notification for one batch and revision carries the same endpoint and
 // differs only by which components changed, so the union of their tokens is the
 // complete set to render.
@@ -93,6 +122,13 @@ function applyFrame(frame) {
   const target = document.getElementById(frame?.target)
   if (!target || !frame.html) return
   if (!newerRevision(frame.revision, target.dataset.solidObjectsRevision)) return
+  // Concurrent same-revision responses can carry the same frame. The target's
+  // own revision only advances once Turbo applies the stream, so what has
+  // already been applied is tracked here as well.
+  const applied = appliedRevisions.get(frame.target)
+  if (applied && !newerRevision(frame.revision, applied)) return
+
+  appliedRevisions.set(frame.target, frame.revision)
 
   const parsed = new DOMParser().parseFromString(frame.html, "text/html")
   const replacement = parsed.getElementById(frame.target)

data/app/controllers/solid_objects/components_controller.rb

@@ -43,10 +43,7 @@ module SolidObjects
         return head :conflict
       end
 
-      authorization_context = SolidObjects
-        .configuration
-        .component_authorization_context
-        .call(controller: self)
+      authorization_context = component_authorization_context(registrations)
       frames = registrations.map do |registration|
         rendered = ComponentRenderer.new(
           snapshot:,
@@ -112,10 +109,7 @@ module SolidObjects
         return head :conflict
       end
 
-      authorization_context = SolidObjects
-        .configuration
-        .component_authorization_context
-        .call(controller: self)
+      authorization_context = component_authorization_context([ registration ])
       rendered = ComponentRenderer.new(
         snapshot:,
         registration:,
@@ -138,6 +132,34 @@ module SolidObjects
       head :bad_request
     end
 
+    # Callbacks written before batching accept only `controller:`. Those keep
+    # working; a callback that also accepts `registrations:` receives one
+    # registration for a single refresh and all of them for a batch.
+    # @rbs (Array[ComponentRegistration]) -> untyped
+    def component_authorization_context(registrations)
+      callable = SolidObjects.configuration.component_authorization_context
+      return callable.call(controller: self) unless accepts_registrations?(callable)
+
+      callable.call(controller: self, registrations:)
+    end
+
+    # A lambda answers `parameters` directly; a callable object answers it
+    # through its `call` method.
+    # @rbs (untyped) -> bool
+    def accepts_registrations?(callable)
+      callable_parameters(callable).any? do |type, name|
+        type == :keyrest || (%i[key keyreq].include?(type) && name == :registrations)
+      end
+    end
+
+    # @rbs (untyped) -> Array[[ Symbol, Symbol ]]
+    def callable_parameters(callable)
+      return callable.parameters if callable.respond_to?(:parameters)
+      return callable.method(:call).parameters if callable.respond_to?(:call)
+
+      []
+    end
+
     # @rbs (ComponentRegistration) -> Hash[Symbol, untyped]
     def registration_payload(registration)
       {

data/docs/realtime.md

@@ -173,8 +173,11 @@ they are while giving the client a documented contract with per-frame revisions.
 ### What the protocol guarantees
 
 Only components whose dependencies changed are requested; the rest are never
-named in the batch. Duplicate notifications for the same batch and revision merge
-into one request, and a superseded request for the same batch is aborted. Each
+named in the batch. Notifications for the same batch and revision that arrive in
+one task merge into a single request. Notifications that arrive in separate
+WebSocket messages issue their own requests and all of their frames are applied,
+because cancelling a same-revision request would drop the components it carried.
+Only a strictly newer revision supersedes an in-flight request. Each
 frame carries its own revision and cannot overwrite a target that already holds a
 newer one. Authorization is unchanged: every component in the batch passes the
 same `authorize_query` boundary an individual refresh uses, and the batch name is
@@ -290,6 +293,20 @@ commonly resolve it to `Current.user`:
 configuration.component_authorization_context = ->(controller:) { Current.user }
 ```
 
+A callback may also accept `registrations:`, which receives one registration for
+a single component refresh and every registration in the group for a batch
+refresh. This avoids decoding `params[:tokens]` by hand when a policy depends on
+which components were requested:
+
+```ruby
+configuration.component_authorization_context = lambda do |controller:, registrations:|
+  Current.user if registrations.all? { |registration| registration.component_key == controller.session[:seat] }
+end
+```
+
+Callbacks that accept only `controller:` continue to work; the extra keyword is
+passed only to callables that declare it.
+
 The three contexts are intentionally different:
 
 | Boundary | Authorization context |

data/docs/roadmap.md

@@ -17,18 +17,26 @@
 - One-shot and recurring reminders with `:latest` or `:all` catch-up
 - Durable observable invalidations, scalar Turbo replacement, keyed ERB
   components, signed component locals, and authorized replace or morph refresh
+- 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
+  subscriber's authorization context, fenced by actor revision
 - Reconciliation read APIs
 - Installation doctor, authorization reference, fit guide, and legacy-state
   migration cookbook
 - Handler Active Record write isolation, same-database commit actions, ambient
-  transaction rejection, adapter lock/query deadlines, structured sync timeout
-  diagnostics, and result recovery
+  transaction rejection, adapter lock/query deadlines, bounded SQLite lock
+  retries outside those deadlines, structured sync timeout diagnostics, and
+  result recovery
 - Bounded message/process pruning, actor-type opt-in instance expiration,
   graceful caller shutdown, committed state snapshots, and an opt-in Minitest
   helper
 - SQLite, PostgreSQL, and MySQL integration suites
 - Inline RBS generation/validation, Steep, Standard Ruby, Solid Queue's exact
   RuboCop policy, and a warning-free Brakeman scan
+- A JavaScript suite covering the state payload and batched refresh browser
+  modules, run in CI with Node's test runner and jsdom, with every GitHub
+  Actions reference pinned to a commit SHA
 
 ## Partially implemented
 
@@ -36,14 +44,24 @@
   role or run periodic maintenance automatically.
 - Wake-up strategy: in-process signaling plus durable polling and injection are
   implemented; PostgreSQL `LISTEN/NOTIFY` and optional Redis adapters are not.
+  Signaling cannot cross process boundaries, so a commit in a web process does
+  not wake a broadcast executor in a worker process; that delivery waits up to
+  `polling_interval`, 100 ms by default. This is the largest remaining term in
+  reactive update latency, and neither batching nor state payloads reduce it.
 - Realtime: scalar and dependency-driven keyed ERB component replacement or
   morphing, personalized refresh authorization, revision fencing, coalescing,
-  and reconnect convergence are implemented; application-directed Turbo
-  append intents are not.
+  reconnect convergence, batched refreshes, and personalized state payloads are
+  implemented; application-directed Turbo append intents are not. Batch
+  coalescing happens in the browser rather than the broadcast executor, so one
+  commit still sends one Action Cable message per changed observable even
+  though it costs one browser request.
 - Backpressure: mailbox/payload/state/result caps and fair yields exist;
   distributed per-actor rate limits and global admission control do not.
 - Administration: actor and dead-letter views plus policy hooks exist; richer
   filtering, audit records, and bulk-safe tools do not.
+- Browser module coverage: the state payload and batched refresh modules have
+  JavaScript tests; `component_refresh.js`, which drives individual morph
+  refreshes, does not.
 - Outboxes use portable status rows with polling indexes; future versions may
   introduce narrow ready/claimed membership tables for very large outboxes.
 
@@ -51,7 +69,8 @@
 
 1. Add automatic supervisor role replacement and periodic dead-process cleanup.
 2. Add PostgreSQL notification and optional Redis wake-up adapters with latency
-   benchmarks and polling-race tests.
+   benchmarks and polling-race tests, removing the cross-process polling delay
+   rather than shrinking it with a smaller `polling_interval`.
 3. Add result lookup by request ID and broader deadlock retry classification.
 4. Add scheduled retention and stale-process maintenance.
 5. Add database/server-version checks and MySQL InnoDB verification at boot.
@@ -61,7 +80,9 @@
 8. Expand security scanning and run compatibility CI across supported Rails and
    Ruby versions.
 9. Benchmark all workloads under documented hardware/database settings and
-   publish adapter-specific adoption measurements.
+   publish adapter-specific adoption measurements. Throughput, synchronous
+   latency, query counts, and the three reactive delivery paths are measured on
+   SQLite; adapter-specific and end-to-end browser measurements are not.
 
 No production-ready claim should be made until these hardening milestones have
 operational soak evidence.

data/lib/solid_objects/component_renderer.rb

@@ -32,6 +32,7 @@ module SolidObjects
       )
       view_context.render(
         partial: default_partial,
+        formats: [ :html ],
         locals: registration.locals.transform_keys(&:to_sym).merge(
           actor:,
           authorization_context:,

data/lib/solid_objects/version.rb

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

data/sig/generated/controllers/solid_objects/components_controller.rbs

@@ -21,6 +21,20 @@ module SolidObjects
     # @rbs (Hash[Symbol, untyped]) -> void
     def refresh: (Hash[Symbol, untyped]) -> void
 
+    # Callbacks written before batching accept only `controller:`. Those keep
+    # working; a callback that also accepts `registrations:` receives one
+    # registration for a single refresh and all of them for a batch.
+    # @rbs (Array[ComponentRegistration]) -> untyped
+    def component_authorization_context: (Array[ComponentRegistration]) -> untyped
+
+    # A lambda answers `parameters` directly; a callable object answers it
+    # through its `call` method.
+    # @rbs (untyped) -> bool
+    def accepts_registrations?: (untyped) -> bool
+
+    # @rbs (untyped) -> Array[[ Symbol, Symbol ]]
+    def callable_parameters: (untyped) -> Array[[ Symbol, Symbol ]]
+
     # @rbs (ComponentRegistration) -> Hash[Symbol, untyped]
     def registration_payload: (ComponentRegistration) -> Hash[Symbol, untyped]
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: solid_objects
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.7.3
 platform: ruby
 authors:
 - Lucas Carlson