hibiki_rails 0.17.1 → 0.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4919aaf1d8c96e1436138dfc5c0050602e0590447ccf9daebb5598072bf01e2d
-  data.tar.gz: 214048d87eec87fa482744750f736eb3d3004381864e69c12b1664a10ffaf9a5
+  metadata.gz: 915a98a11ca62685f60697d27383e8592978e0c2173b0e984c24eca7736cef55
+  data.tar.gz: 070cd14175c3027b164ec0b52378b59178499f3f3474fe3296722f6432c580ab
 SHA512:
-  metadata.gz: f1da64047eb007f11f45f55007519808ad717f9b53968273455586c3977486f1e03e2478f9041c05a7f9d889191d6591a7e116e21d918dfb7719b337e0eeed3b
-  data.tar.gz: 1ed922620989a1997ef4231a7c2e737cbca070ff3c3917966c74b1ed48c28e087e08fd7763152eeb96b713e8675b5126d831b07e5e4dc10e22c31d20cb908fdb
+  metadata.gz: 5d07fa8e0a897a21cce85e559e42a02dc78090f89986bc37c24202a36fb81322287a1ae86fb4c5166aa615a4ee8924732bb63020643a2e4db8e8ec72a5d870eb
+  data.tar.gz: 993b20b7af2d105e5c067823621eb8050ff426a57a9ac0b0aacccbd2a9fd9136a9a2a6f0f635d7932952f7c4c58bef2645492c67fe1b79acbb28d1c2e86f5a37

data/CHANGELOG.md

@@ -4,6 +4,87 @@ The gem and the npm package are released in lockstep and share these version
 numbers — `app/assets/javascripts/hibiki.js` is a single copy served both ways,
 so importmap and bundler apps always resolve identical client code.
 
+## 0.18.0 — 2026-10-11
+
+### Added
+
+**Instrumentation events.** A channel now publishes
+`ActiveSupport::Notifications` events, so an app can time what a graph does.
+Action Cable's own `perform_action.action_cable` covers only the hand-off to
+the graph's thread; the action, its effects and its renders run after it.
+
+| Event | Duration covers | Payload |
+|---|---|---|
+| `subscribe.hibiki_rails` | building the graph and its first renders | `channel` |
+| `unsubscribe.hibiki_rails` | disposing the graph | `channel` |
+| `action.hibiki_rails` | the action and every effect it flushed | `channel`, `action`, `wait`, `renders` |
+| `render.hibiki_rails` | one `broadcast_replace`, `broadcast_morph` or `broadcast_refresh` | `channel`, `target`, `method` |
+
+- The events are always on and need no configuration. The gem subscribes to
+  none of them. With no subscriber an action costs one to two microseconds
+  more than in 0.17.2.
+- A subscriber runs on the graph's thread, so keep it to cheap work in
+  memory.
+- An action the channel does not have publishes nothing. A raising action
+  publishes, with the exception in the payload.
+- `transmit_value` and `transmit_url` have no event of their own; Action
+  Cable's `transmit.action_cable` covers them.
+
+**`Hibiki::Rails.registry.tally`** returns the live subscriptions by channel
+class name.
+
+**Trips: how long a visitor waited.** With `HibikiController.reportTrips =
+true`, each island times its round trips and sends them with its next action.
+The channel publishes one `trip.hibiki_rails` event for each, with `channel`,
+`action`, `ack` (milliseconds until the server answered) and `paint`
+(milliseconds until the first render arrived, or `nil`).
+
+- Off by default. Set it once, on the class, for every island.
+- A dropped or stalled trip is not reported, and neither is the last trip on
+  a page, since no action follows it.
+- The figures come from the browser. The channel takes at most five per
+  action, only for its own actions, and clamps each to 0 to 60 000 ms.
+- `hbt` joins `hbk` as a reserved payload key. The channel removes it before
+  the action method sees its data.
+
+## 0.17.2 — 2026-10-11
+
+### Fixed
+
+**A save the model refused could leave a `reactive_association` form unable
+to save.** The form keeps one record between attempts. When a `commit` was
+refused, the join rows were rolled back, but the record still remembered the
+selection that attempt had written, and the next `commit` was compared with
+that memory instead of the table. If the refused attempt had removed an id
+that the next one still held, the retry inserted a join row that was already
+there. With a unique index on the pair, which the `multiselect` generator
+writes, that raised `ActiveRecord::RecordNotUnique` and the visitor saw a
+Save that did nothing, every time, until the form was opened again. Without
+the index it wrote a duplicate row.
+
+- Any refused save could set it up, not only one about the association: a
+  blank name saved together with a removed tag was enough.
+- A refused `commit` or `commit!` now unloads the associations named in
+  `reactive_association`, and the join association behind a
+  `has_many :through` or a `has_and_belongs_to_many`. The form keeps the
+  visitor's selection; nothing changes in the channel or the view.
+- An app that calls `record.reload` before `commit` to get round this can
+  remove the call.
+- `hibiki_associations` on a form class lists the names it declared.
+
+**A form that had saved once could save its `reactive_association` wrongly
+after another session changed the same record.** The cause is the same
+memory. If the other session had added an id this form then added too, the
+commit raised `ActiveRecord::RecordNotUnique`. If it had removed an id this
+form still showed, the commit returned `true` and did not write it.
+
+- `commit` now reads the association from the table each time, at the cost
+  of one query per association when it was already loaded.
+- The later save still wins: the form's selection replaces the other
+  session's, as its other fields already did.
+- Nested forms (`reactive_nested`) are not changed.
+- The npm package is unchanged apart from its version.
+
 ## 0.17.1 — 2026-10-09
 
 ### Fixed

data/README.md

@@ -125,6 +125,52 @@ The generated components are just Rails partials (or Phlex components, if you us
 
 Congratulations! Now you have your first reactive component!
 
+## Instrumentation
+
+A channel publishes `ActiveSupport::Notifications` events. They are always
+on, and the gem subscribes to none of them.
+
+| Event | Duration covers | Payload |
+|---|---|---|
+| `subscribe.hibiki_rails` | building the graph and its first renders | `channel` |
+| `unsubscribe.hibiki_rails` | disposing the graph | `channel` |
+| `action.hibiki_rails` | the action and every effect it flushed | `channel`, `action`, `wait`, `renders` |
+| `render.hibiki_rails` | rendering and handing the stream to Action Cable | `channel`, `target`, `method` |
+| `trip.hibiki_rails` | nothing | `channel`, `action`, `ack`, `paint` |
+
+```ruby
+ActiveSupport::Notifications.subscribe("action.hibiki_rails") do |event|
+  Rails.logger.info "#{event.payload[:channel]}##{event.payload[:action]} #{event.duration.round(1)}ms"
+end
+```
+
+- `channel` is the class name. `wait` is the milliseconds the action queued
+  for the graph's thread. `renders` is how many renders it caused.
+- `method` is `:replace`, `:morph` or `:refresh`. A refresh has no `target`.
+- An action the channel does not have publishes nothing. A raising action
+  publishes, with the exception in the payload.
+- Action Cable's `broadcast.action_cable` fires inside the render event, on
+  the same thread, and carries the message if you want its size.
+- `Hibiki::Rails.registry.tally` returns the live subscriptions by channel
+  class, and `registry.size` the total.
+
+**A subscriber runs on the graph's thread.** Keep it to cheap work in
+memory; anything slow holds up that visitor's actions.
+
+A `trip` is the browser's own timing of one action: `ack` is the
+milliseconds until the server answered and `paint` the milliseconds until
+its first render arrived, or `nil` when nothing rendered. Reporting is off
+until the app turns it on:
+
+```js
+import HibikiController from "hibiki-rails"
+HibikiController.reportTrips = true
+```
+
+Each island then sends its last trips with its next action. The figures come
+from visitors' browsers, so treat them as reported: the gem bounds them (five
+per action, known action names, 0 to 60 000 ms) and cannot verify them.
+
 ## Documentation
 
 Documentation site: <https://planetaska.github.io/hibiki/rails-introduction/>

data/app/assets/javascripts/hibiki.js

@@ -284,6 +284,10 @@ export class ChannelController extends Controller {
   static busyCeiling = 10000
   static focusGrace = 500
 
+  // Whether to tell the server how long each trip took (see "Trips"
+  // below). Off unless an app sets it, once, for every island.
+  static reportTrips = false
+
   async connect() {
     this.prepareTransport()
     await this.openSubscription()
@@ -302,6 +306,7 @@ export class ChannelController extends Controller {
     this.seq = 0
     this.renders = 0
     this.busy = new Map()
+    this.trips = []
     this.settledAt = -Infinity
     this.lastControl = null
     this.queued = []
@@ -345,7 +350,8 @@ export class ChannelController extends Controller {
   // a sequence number under the reserved `hbk` key and opens a busy record
   // that the matching ack closes; the seq is stamped LAST so a form field
   // can never overwrite it. (`hbk` is the second reserved payload key —
-  // ActionCable's own Subscription#perform already writes `action`.)
+  // ActionCable's own Subscription#perform already writes `action`. `hbt`
+  // is the third: the trips timed since the last perform.)
   //
   // Public API on the island controller (the header's "App JS reaching
   // the graph"). Returns the seq when the action was accepted, so a
@@ -356,8 +362,10 @@ export class ChannelController extends Controller {
   perform(action, payload = {}) {
     const seq = ++this.seq
     payload.hbk = seq
+    delete payload.hbt
     if (this.subscribed) {
-      this.beginBusy(seq)
+      this.sendTrips(payload)
+      this.beginBusy(seq, action)
       // Subscription#perform returns false when the socket is not open —
       // the gap between the socket dying and the connection monitor
       // noticing, during which `subscribed` still says live. The frame
@@ -383,7 +391,8 @@ export class ChannelController extends Controller {
     // whole gap — the signal the connect window cannot give, where the
     // page is painted and looks live.
     if (!this.connectedOnce) {
-      this.beginBusy(seq)
+      this.sendTrips(payload)
+      this.beginBusy(seq, action)
       this.queued.push([action, payload])
       return seq
     }
@@ -430,9 +439,11 @@ export class ChannelController extends Controller {
   // means the server has not answered, and a hold is motion after the
   // answer.
 
-  beginBusy(seq) {
+  beginBusy(seq, action) {
     const record = {
       control: null,
+      action,
+      at: performance.now(),
       // Which render the island was on when this started, so the ack can
       // ask "has anything painted since?" without consulting a clock.
       renders: this.renders,
@@ -486,6 +497,7 @@ export class ChannelController extends Controller {
     if (this.state === "stalled") this.setState("ready")
     const record = this.busy.get(ack)
     if (!record) return
+    if (!dropped) record.ack = Math.round(performance.now() - record.at)
     if (dropped || this.renders > record.renders) return this.settle(ack)
     record.grace = setTimeout(() => this.settle(ack), this.constructor.busyGrace)
   }
@@ -499,6 +511,7 @@ export class ChannelController extends Controller {
     this.settledAt = performance.now()
     record.control?.removeAttribute("data-hibiki-busy")
     if (this.busy.size === 0) this.hideBusy()
+    if (record.ack !== undefined && this.constructor.reportTrips) this.keepTrip(record)
   }
 
   settleAll() {
@@ -528,13 +541,49 @@ export class ChannelController extends Controller {
     this.setState("stalled")
   }
 
+  // ── Trips ─────────────────────────────────────────────────────────────
+  //
+  // Only the browser sees both halves of a trip land: the ack on the
+  // island's socket and the render after its pubsub hop. With reportTrips
+  // on, each acked trip is kept as its action, the ms to the ack and the ms
+  // to the first render of its own (null when nothing rendered), and the
+  // next perform carries the last five under `hbt`. A dropped or stalled
+  // trip is not reported, and the last trip on a page never is.
+
+  keepTrip({ action, at, ack, paint }) {
+    this.trips.push({ action, at, ack, paint, settled: this.settledAt })
+    if (this.trips.length > 5) this.trips.shift()
+  }
+
+  sendTrips(payload) {
+    if (!this.trips.length) return
+    payload.hbt = this.trips.map(({ action, ack, paint }) => [action, ack, paint ?? null])
+    this.trips = []
+  }
+
+  // A render of this island's own has arrived. Timed now, not when it is
+  // applied: the order and motion holds come after the answer. A trip that
+  // settled a moment ago still takes it, by the rule own() uses.
+  arrived() {
+    const now = performance.now()
+    for (const record of this.busy.values()) record.paint ??= Math.round(now - record.at)
+    for (const trip of this.trips) {
+      if (trip.paint === undefined && now - trip.settled <= this.constructor.focusGrace) {
+        trip.paint = Math.round(now - trip.at)
+      }
+    }
+  }
+
   // Every inbound frame lands here first. Acks are transport bookkeeping,
   // handled by the base and deliberately NOT routed through received() — so
   // a subclass that overrides received without calling super still clears
   // its pending state.
   handleMessage(data) {
     if (data && "ack" in data) return this.acknowledge(data)
-    if (data && data.html) this.renders++
+    if (data && data.html) {
+      this.renders++
+      this.arrived()
+    }
     this.received(data)
   }
 
@@ -855,6 +904,9 @@ export default class HibikiController extends ChannelController {
     this.streamRender = (event) => {
       const render = event.detail.render
       const stream = event.detail.newStream
+      if (stream?.getAttribute?.("data-hibiki-from") === `${this.channelValue}/${this.cidValue}`) {
+        this.arrived()
+      }
       // Taken now, not when the render's turn comes: see arrival().
       const arrival = this.arrival()
       event.detail.render = (streamElement) =>

data/lib/hibiki/rails/broadcasts.rb

@@ -13,14 +13,19 @@ module Hibiki
     # All private — a public helper would become a client-invocable action
     # (see the NOTE on Hibiki::Rails::Channel).
     module Broadcasts
+      include Instrumentation
+
       private
 
       # Replace the element with DOM id `target` (accepts partial:/locals:,
       # html:, or anything Turbo's renderer takes).
       def broadcast_replace(target:, attributes: {}, **rendering)
-        Turbo::StreamsChannel.broadcast_replace_to(
-          *stream_name, target:, attributes: attributes.merge(render_stamp), **rendering
-        )
+        method = attributes[:method].to_s == "morph" ? :morph : :replace
+        instrument_render(target:, method:) do
+          Turbo::StreamsChannel.broadcast_replace_to(
+            *stream_name, target:, attributes: attributes.merge(render_stamp), **rendering
+          )
+        end
       end
 
       # Replace via Turbo 8 morphing (<turbo-stream action="replace"
@@ -32,7 +37,7 @@ module Hibiki
       # Tell the page to refresh itself (Turbo 8 morph-everything style).
       # Pair with Debounce when many writes should mean one refresh.
       def broadcast_refresh
-        Turbo::StreamsChannel.broadcast_refresh_to(*stream_name)
+        instrument_render(method: :refresh) { Turbo::StreamsChannel.broadcast_refresh_to(*stream_name) }
       end
 
       # The Morph-everything style as one call: an effect that tracks

data/lib/hibiki/rails/channel.rb

@@ -77,13 +77,20 @@ module Hibiki
       # produces zero bytes, and "clear on the next render" would hang
       # forever. `delete`, not `[]`: the key must not reach the action
       # method's data. No `hbk`, no ack, so a 0.3.0 page keeps working.
+      #
+      # `hbt` is the third reserved key: the trips the browser timed since
+      # its last action (see Instrumentation#trips_from). Deleted whether or
+      # not anyone listens, for the same reason as `hbk`.
       def perform_action(data)
         seq = data.delete("hbk")
+        trips = trips_from(data.delete("hbt"))
+        asked = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
         # A nil actor means the subscription was rejected or already torn
         # down; drop the action rather than blow up the cable thread.
         posted = @__hibiki_actor&.post do
-          Hibiki.batch { super(data) }
+          trips.each { instrument("trip", it) }
+          instrument_action(data, asked) { Hibiki.batch { super(data) } }
         ensure
           # Hibiki.batch flushes in its own ensure, so effects queued
           # before a raise have run by the time this does — the ack is
@@ -111,7 +118,9 @@ module Hibiki
         # The block runs owned + untracked (Hibiki.root); the effects it
         # creates do their dependency-collecting first run right here, on
         # the graph thread.
-        @__hibiki_actor.post { @__hibiki_root = Hibiki.root { build_graph } }
+        @__hibiki_actor.post do
+          instrument("subscribe") { @__hibiki_root = Hibiki.root { build_graph } }
+        end
         Hibiki::Rails.registry.register(self)
       end
 
@@ -123,7 +132,7 @@ module Hibiki
         return unless @__hibiki_actor
 
         Hibiki::Rails.registry.unregister(self)
-        @__hibiki_actor.post { @__hibiki_root.dispose }
+        @__hibiki_actor.post { instrument("unsubscribe") { @__hibiki_root.dispose } }
         @__hibiki_actor.stop
       end
 

data/lib/hibiki/rails/instrumentation.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Hibiki
+  module Rails
+    # The channel's ActiveSupport::Notifications events (`*.hibiki_rails`).
+    # Always on: with no subscriber `instrument` only yields. The gem
+    # subscribes to none of them. A subscriber runs on the graph thread, so
+    # it holds up that graph for as long as it takes.
+    #
+    # All private — a public helper would become a client-invocable action
+    # (see the NOTE on Hibiki::Rails::Channel).
+    module Instrumentation
+      # The most trips one action may report, and the longest time one may
+      # claim, in ms. The figures come from a browser, so they are bounded
+      # rather than believed.
+      TRIP_LIMIT = 5
+      TRIP_RANGE = (0..60_000)
+
+      EVENTS = %w[subscribe unsubscribe action render trip].to_h { [it, "#{it}.hibiki_rails"] }.freeze
+
+      private
+
+      # With nobody listening this is one lookup and a yield; no payload is
+      # built.
+      def instrument(event, payload = nil, &)
+        return (yield({}) if block_given?) unless listening?(event)
+
+        ActiveSupport::Notifications.instrument(EVENTS.fetch(event), { channel: self.class.name, **payload }, &)
+      end
+
+      # `asked` is the clock as the cable thread posted the action; `wait` is
+      # how long the graph thread took to reach it, in ms. An action the
+      # channel does not have gets no event: the name is the client's, and a
+      # subscriber that stores it must not be handed arbitrary strings.
+      def instrument_action(data, asked)
+        action = data["action"].to_s
+        return yield unless listening?("action") && self.class.action_methods.include?(action)
+
+        before = @__hibiki_render_count.to_i
+        instrument("action", { action:, wait: ms_since(asked) }) do |payload|
+          yield
+        ensure
+          payload[:renders] = @__hibiki_render_count.to_i - before
+        end
+      end
+
+      def listening?(event) = ActiveSupport::Notifications.notifier.listening?(EVENTS.fetch(event))
+
+      def ms_since(clock) = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - clock) * 1000
+
+      def instrument_render(method:, target: nil, &)
+        @__hibiki_render_count = @__hibiki_render_count.to_i + 1
+        instrument("render", { target:, method: }.compact, &)
+      end
+
+      # The trips a browser reported under `hbt`, as event payloads. Each is
+      # `[action, ack, paint]`: ms to the ack, and ms to the first render, or
+      # nil when nothing rendered.
+      def trips_from(reported)
+        reported.is_a?(Array) ? reported.first(TRIP_LIMIT).filter_map { trip(*it) } : []
+      end
+
+      def trip(action = nil, ack = nil, paint = nil, *)
+        return unless action.is_a?(String) && self.class.action_methods.include?(action)
+        return unless ack.is_a?(Numeric) && (paint.nil? || paint.is_a?(Numeric))
+
+        { action:, ack: ack.clamp(TRIP_RANGE), paint: paint&.clamp(TRIP_RANGE) }
+      end
+    end
+  end
+end

data/lib/hibiki/rails/reactive_form.rb

@@ -77,6 +77,7 @@ module Hibiki
         def reactive_association(*names)
           raise "#{self}: declare reactive_attributes before reactive_association" unless __hibiki_model_declared?
 
+          @hibiki_associations = [*hibiki_associations, *names.map(&:to_sym)]
           names.each { |name| __hibiki_ids_signal(name) }
         end
 
@@ -108,6 +109,10 @@ module Hibiki
           @hibiki_nested || __hibiki_inherited(:hibiki_nested) || {}
         end
 
+        def hibiki_associations
+          @hibiki_associations || __hibiki_inherited(:hibiki_associations) || []
+        end
+
         # The child form class, resolved on every use like hibiki_model so
         # a String declaration never pins a constant across a reload.
         def hibiki_nested_form(name)
@@ -259,7 +264,7 @@ module Hibiki
       # have moved values, and #persisted? flips after an INSERT.
       # rubocop:disable-next Naming/PredicateMethod -- boolean without a ?, exactly like AR's #save
       def commit
-        record = __hibiki_record!
+        record = __hibiki_unloaded_record
         if record.update(**to_h)
           # Unload before re-hydrating, so the reload honors the
           # association's own scope and drops destroyed rows.
@@ -272,13 +277,13 @@ module Hibiki
           # update APPENDS its built new children to the in-memory
           # association — a later success would insert them all again.
           # Unloading makes the next attempt start clean.
-          __hibiki_reset_nested(record)
+          __hibiki_unload(record)
           false
         end
       end
 
       # The raising half. Re-assigns and raises ActiveRecord::RecordInvalid
-      # (no rescue, and no AR constant named here); the nested associations
+      # (no rescue, and no AR constant named here); the record's associations
       # are unloaded even on the raise, so a rescued retry starts clean.
       def commit!
         return true if commit
@@ -287,7 +292,7 @@ module Hibiki
         begin
           record.update!(**to_h)
         ensure
-          __hibiki_reset_nested(record)
+          __hibiki_unload(record)
         end
       end
 
@@ -359,6 +364,34 @@ module Hibiki
         self.class.hibiki_nested.each_key { |name| record.public_send(name).reset }
       end
 
+      # What a refused attempt leaves behind on the record.
+      def __hibiki_unload(record)
+        __hibiki_reset_nested(record)
+        __hibiki_reset_associations(record)
+      end
+
+      # A refused update rolls the join rows back, but the ids writer has
+      # already left the association holding the refused set, and the join
+      # association behind a :through (or a has_and_belongs_to_many) holding
+      # the join records it built. The next ids write would be diffed
+      # against that memory instead of the table, so both are unloaded.
+      def __hibiki_reset_associations(record)
+        self.class.hibiki_associations.each do |name|
+          association = record.association(name)
+          association.reset
+          reflection = association.reflection
+          record.association(reflection.through_reflection.name).reset if reflection.through_reflection?
+        end
+      end
+
+      # The record to write to. Its ids associations are unloaded first, so
+      # the ids writer reads the table and not what this record remembers
+      # from an earlier commit or a preload: rows another session wrote
+      # since would otherwise be inserted twice, or silently left out.
+      def __hibiki_unloaded_record
+        __hibiki_record!.tap { __hibiki_reset_associations(it) }
+      end
+
       def __hibiki_record!
         record || raise("#{self.class} has no record — build it with .from(record)")
       end

data/lib/hibiki/rails/registry.rb

@@ -28,6 +28,13 @@ module Hibiki
         @lock.synchronize { @channels.size }
       end
 
+      # The live subscriptions by channel class name. Count from this rather
+      # than from subscribe and unsubscribe events: a development reload
+      # drops sockets without running `unsubscribed`.
+      def tally
+        @lock.synchronize { @channels.map { it.class.name }.tally }
+      end
+
       # Close each distinct cable connection, which routes every one of
       # its channels through the normal unsubscribed path — dispose root,
       # stop actor, unregister — so teardown has exactly ONE code path and

data/lib/hibiki/rails/version.rb

@@ -2,6 +2,6 @@
 
 module Hibiki
   module Rails
-    VERSION = "0.17.1"
+    VERSION = "0.18.0"
   end
 end

data/lib/hibiki/rails.rb

@@ -68,6 +68,7 @@ require_relative "rails/version"
 require_relative "rails/registry"
 require_relative "rails/graph_actor"
 require_relative "rails/debounce"
+require_relative "rails/instrumentation"
 require_relative "rails/broadcasts"
 require_relative "rails/channel"
 require_relative "rails/nested_actions"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hibiki_rails
 version: !ruby/object:Gem::Version
-  version: 0.17.1
+  version: 0.18.0
 platform: ruby
 authors:
 - planetaska
@@ -187,6 +187,7 @@ files:
 - lib/hibiki/rails/engine.rb
 - lib/hibiki/rails/graph_actor.rb
 - lib/hibiki/rails/helpers.rb
+- lib/hibiki/rails/instrumentation.rb
 - lib/hibiki/rails/keys.rb
 - lib/hibiki/rails/nested_actions.rb
 - lib/hibiki/rails/reactive_form.rb
@@ -216,7 +217,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.16
+rubygems_version: 4.0.20
 specification_version: 4
 summary: 'Rails glue for hibiki: connection-scoped signal graphs over ActionCable
   + Turbo Streams.'