hibiki_rails 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 73beec766683bf4a92c8bebcb19b62e58686f50f68e3b16f0a958c2d0d155de1
-  data.tar.gz: 8ce7469020b298e4e94b7fa7daef8bafb5443a891fc90163339750f400aa9228
+  metadata.gz: 45614c5c98f4439de6f22da45a49d163ab7a06eccf53ed36108ee04d6b5c7f78
+  data.tar.gz: c1dd28764cc7462dbb7ceaa5d0b76e1a0371bd8cc5523fe54545533d7b759c36
 SHA512:
-  metadata.gz: 3f5fc7f1fe7a4f72047d86e054612e9144e5815cc1a96d2fa87737573f9701ce2b2c6d713992822ee6cd90cae7b6cae5b4647bb6001b3f863dee2f38354ec131
-  data.tar.gz: 67f0275c2e22bd291fc8940f84a99775c9e1acac5e3542ffc68edd9c896e26f9e786270904bfa75029e78c872984560fdeca6499532f4128c4f65a1c420ab7b2
+  metadata.gz: 4908f9d337c86d575287ff2d21d3d74cd112334e893e8b042cb07e7e8a1de141ddd892b17b4b86d90ac2008ce8c7d9f4390fd1ebdd1cc1cafe88e75c6530c360
+  data.tar.gz: 392976be271a02c7b5e354ec0d3e46117e1a8772cb0a68b99d4570f1f95309bc7abac3e0cd3ca38961eaea5eb849d4e4343effa55911629d367555949ac93408

data/README.md

@@ -1,252 +1,86 @@
 # hibiki_rails
 
 Rails glue for [hibiki](https://github.com/planetaska/hibiki):
-connection-scoped signal graphs over ActionCable, pushing re-rendered HTML
-to the page — either through Turbo Streams, or over the channel's own
-subscription to the gem's packaged client (see "The packaged client").
+connection-scoped signal graphs over ActionCable, pushing re-rendered HTML to the page — either through Turbo Streams, or over the channel's own subscription to the gem's packaged client (see [The JS client](https://planetaska.github.io/hibiki/the-js-client/)).
 
 ```
 cable action arrives → mutate signals → effects render partials →
 Turbo Streams broadcast → Turbo morphs the DOM
 ```
 
-A graph lives per cable connection (in practice: per browser tab), built
-when the channel subscribes and disposed when it unsubscribes. Effects
-subscribe to whatever signals they read; when an action writes a signal,
-exactly the affected effects re-render and broadcast.
+A graph lives per cable connection (in practice: per browser tab), built when the channel subscribes and disposed when it unsubscribes. Effects subscribe to whatever signals they read; when an action writes a signal, exactly the affected effects re-render and broadcast.
 
-Incubating inside the hibiki repo while the core gem is pre-release; will
-be extracted to its own repository once hibiki 0.1.0 ships and this API
-stabilizes. Rails >= 8.0 (what's tested), Ruby >= 3.4.
+Supports Rails >= 7.1, Ruby >= 3.4.
 
-## Usage
+## Rails quick start
+
+### Installation
+
+**Step 1** - Install the gem (`hibiki_rails` depends on the core `hibiki` gem)
 
 ```ruby
-class CounterChannel < ApplicationCable::Channel
-  include Hibiki::Rails::Channel
-
-  # Runs once on the graph's own thread, inside Hibiki.root.
-  def build_graph
-    @count = Hibiki::State.new(0)
-    @step  = Hibiki::State.new(1)
-    doubled = Hibiki::Derived.new { @count.value * 2 }
-
-    Hibiki::Effect.new do
-      broadcast_replace target: "count", partial: "counter/count",
-                        locals: { count: @count.value, doubled: doubled.value }
-    end
-    Hibiki::Effect.new do
-      broadcast_replace target: "step", partial: "counter/step",
-                        locals: { step: @step.value }
-    end
-  end
-
-  # Actions are plain methods that touch signals directly: each one runs
-  # on the graph thread inside one Hibiki.batch, so N writes still mean
-  # one re-run per affected effect.
-  def increment = @count.value += @step.value
-  def burst     = 10.times { @count.value += 1 }
-end
+# Gemfile
+gem "hibiki"
+gem "hibiki_rails"
 ```
 
-The page supplies a per-page-load graph id (`cid`) and listens on the
-matching stream:
+Or `gem install hibiki hibiki_rails`.
 
-```erb
-<div data-controller="counter" data-counter-cid-value="<%= @cid %>">
-  <%= turbo_stream_from "counter", @cid %>
-  <%= render "count", count: 0, doubled: 0 %>  <%# placeholder, see below %>
-  ...
-</div>
-```
+**Step 2** - Run the install generator
 
-with `@cid = SecureRandom.uuid` in the controller action. The channel
-broadcasts to `[channel_name, cid]` — override `stream_name` (and/or
-`cid`) to derive identity differently.
-
-## What the concern does
-
-- `subscribed` — rejects without a `cid` param, then runs `build_graph`
-  inside `Hibiki.root` on a dedicated worker thread (a `GraphActor`).
-  ActionCable dispatches on a thread pool with no per-channel ordering;
-  hibiki's threading model is confinement — so cable threads only enqueue,
-  and the graph lives on exactly one thread.
-- every action — the whole body is posted to that thread wrapped in one
-  `Hibiki.batch`. `rescue_from` still applies (it runs on the graph
-  thread); what it doesn't handle goes to `Rails.error` (source
-  `"hibiki_rails"`).
-- `unsubscribed` — disposes the root (running `on_cleanup` hooks) and
-  stops the worker, draining what was already queued.
-- dev reloading — an Engine hook disposes every live graph before code
-  reloads (stale effects would run old class versions forever); cable
-  clients auto-reconnect and rebuild. Graph state resets on reload, like
-  any remount.
-
-## Broadcast helpers
-
-Available inside effects (all bound to `stream_name`):
-
-- `broadcast_replace(target:, **rendering)` — `partial:`/`locals:`,
-  `html:`, or anything Turbo's renderer accepts.
-- `broadcast_morph(target:, **rendering)` — replace via Turbo 8 morphing
-  (keeps focus/scroll).
-- `broadcast_refresh` — tell the page to refresh itself.
-- `broadcast_refresh_effect(wait: 0.25) { ...read signals... }` — the
-  morph-everything style: tracks whatever the block reads and answers
-  changes with a debounced refresh, one per burst of actions rather than
-  one per action.
-
-## The packaged client
-
-The gem vendors its own JavaScript, turbo-rails-style: the engine puts
-`hibiki.js` on the app's asset path and merges the `"hibiki-rails"` pin into the
-import map, so importmap-rails apps have no install step beyond
-registering the controller — `bin/rails g hibiki:rails:install` does it
-(plus the `Helpers` include below, the `ApplicationCable` boilerplate,
-and the `@rails/actioncable` pin — a stock app has neither until its
-first `rails g channel`), or create the one-line shim yourself:
-
-```js
-// app/javascript/controllers/hibiki_controller.js
-export { default } from "hibiki-rails" // registers as "hibiki" — the helpers hardcode that identifier
+```sh
+bin/rails g hibiki:rails:install
 ```
 
-The registration is a file-backed shim on purpose: importmap apps
-eager-load it from the controllers directory, jsbundling apps get the
-matching import/register pair in `controllers/index.js` (the install
-generator appends it), and because it is derived from a real controller
-file, `bin/rails stimulus:manifest:update` regenerates it instead of
-dropping it.
+The install generator detects whether your app uses an import map:
 
-(jsbundling/vite apps: `npm install hibiki-rails` — the [npm
-package](https://www.npmjs.com/package/hibiki-rails) is the same module the
-engine vendors, and pulls in `@rails/actioncable`; release in lockstep with
-the gem.)
+- For importmap apps, installation is fully automatic — you are done.
+- For apps with a JS bundler (esbuild, vite, bun, ...), also install the companion JS client (published as an npm package) with **one of**:
+  - `npm install hibiki-rails`
+  - `yarn add hibiki-rails`
+  - `bun add hibiki-rails`
+  - or the equivalent for your setup
 
-The client is one generic Stimulus controller that drives any *island*: a
-DOM subtree bound to one channel subscription. Islands are stamped with
-the opt-in `Hibiki::Rails::Helpers` — include it where you want the bare
-names (`ApplicationHelper` for ERB, individual Phlex components); the gem
-never includes it for you:
+### Using the generator
 
-```erb
-<%= tag.div(**hibiki_island(TodosChannel, cid: @cid)) do %>
-  <%= render TodoList.new %>  <%# placeholder; replaced by DOM id %>
-  <%= tag.form(**on(:add, event: :submit)) do %>
-    <input type="text" name="title">
-    <button>add</button>
-  <% end %>
-<% end %>
-```
+You can create reactive components easily with the provided generators.
 
-- `hibiki_island(channel, cid:)` — the island root: one subscription,
-  identified by the page's `cid`.
-- `on(action, event:, with:)` — forward a DOM event (`:click` default,
-  `:change`, `:submit`) as a channel action, with `with:` as its payload.
-  A changed control also sends `{ name => value }`; a submitted form sends
-  its FormData and is reset after performing.
+Create your first reactive component by running:
 
-Transport is the channel's own subscription in both directions: render
-effects call `transmit({ html: })` and the client swaps each fragment in
-by its root DOM id (`Hibiki::Phlex.render_effect` pairs naturally):
+```sh
+# Replace [your_view_path] with your desired view path,
+# e.g. counters, posts, users/profile...
+bin/rails g hibiki:rails:stimulus counter [your_view_path]
 
-```ruby
-def build_graph
-  @list = TodoList.new
-  Hibiki::Phlex.render_effect(@list) { |html| transmit({ html: }) }
-end
+# For example, this creates "counter" component partials
+# inside app/views/static_pages
+bin/rails g hibiki:rails:stimulus counter static_pages
 ```
 
-Because the client registers its `received` callback at subscribe time —
-before the server ever runs `build_graph` — the effects' first transmits
-always land: no Turbo stream, no connected-wait, and the server-rendered
-initial HTML is only a paint-avoidance placeholder. One rule carries over
-from any replace-fragment design: never transmit a fragment containing
-the input the user is currently typing in.
-
-The `data-hibiki-*` attributes the helpers emit are a private contract
-with the vendored JS — they version together; don't hand-write them in
-app code. The protocol itself is Stimulus-free (Stimulus only hosts the
-controller lifecycle), so a hand-rolled client can drive the same
-attributes: `toy-phlex/` in the parent repo does it in ~40 lines. The
-helper interface's shape is inspired by
-[phlex-reactive](https://phlex-reactive.zoolutions.llc)'s `on(...)`
-actions.
-
-## Generators
-
-Each supported shape has a generator that scaffolds it as a *working*
-mini-example — one state, one derived, one action, one effect; run it,
-render the output from any page, click `+1`, watch it live-update — meant
-to be reshaped in place, not filled in from scratch:
+This creates a minimal working reactive component in the given view path.
 
-```sh
-bin/rails g hibiki:rails:install                  # one-time wiring: register line,
-                                                  # Helpers include, ApplicationCable
-                                                  # boilerplate + actioncable pin
-                                                  # (idempotent)
-bin/rails g hibiki:rails:stimulus NAME [VIEW_PATH]  # channel + ChannelController
-                                                    # subclass + view partial
-bin/rails g hibiki:rails:island NAME [VIEW_PATH]    # channel + helpers-stamped view
-                                                    # partial, no per-component JS
-bin/rails g hibiki:rails:phlex NAME                 # channel + Phlex component +
-                                                    # island wrapper (needs hibiki_phlex)
-```
+### Render the reactive component
+
+The generated components are just Rails partials (or Phlex components, if you used the Phlex generator), so you can render one anywhere like any other partial:
 
-`VIEW_PATH` is the views directory under `app/views` (defaults to `NAME`);
-the emitted partial is self-contained (`cid` defaults to a per-render
-uuid), so `<%= render "counter/counter" %>` — or `<%= render
-CounterIsland.new %>` for the Phlex shape — is the only line a page needs.
-The `stimulus` shape works with zero wiring; `island` and `phlex` need the
-one-time `hibiki:rails:install` (they print a hint when it's missing).
-Namespaced names work (`admin/counter` pins `static channel` where the
-Stimulus identifier can't infer it). In apps without an importmap
-(jsbundling/vite), where `controllers/index.js` has no eager loader, the
-`stimulus` generator also appends the controller's import/register pair
-to it — the same lines `stimulus:manifest:update` would emit.
-
-## The initial-state pattern (Turbo transport)
-
-Islands on the Turbo-broadcast transport instead (the "Usage" example
-above) have an ordering problem the transmit transport doesn't: the
-graph's effects do their first run inside `subscribed` — usually before
-the page's `turbo_stream_from` subscription has confirmed — so the first
-broadcast would be lost. Fix the ordering on the client with the packaged
-`streamConnected` helper: wait for Turbo to stamp the `connected`
-attribute on the stream source, then subscribe the graph channel.
-
-```js
-// in the Stimulus controller driving the channel
-import { streamConnected } from "hibiki-rails"
-
-async connect() {
-  this.consumer = createConsumer()
-  await streamConnected(this.element.querySelector("turbo-cable-stream-source"))
-  this.subscription = this.consumer.subscriptions.create(
-    { channel: "CounterChannel", cid: this.cidValue }, {}
-  )
-}
+```erb
+<%= render "static_pages/counter" %>
 ```
 
-With that in place the server-rendered initial HTML is only a
-paint-avoidance placeholder — the first broadcast always lands and
-replaces it, so it doesn't have to match the graph's initial state.
+Congratulations! Now you have your first reactive component!
 
-## Error handling layers
+## Documentation
 
-1. `rescue_from` on the channel — handles action errors, on the graph
-   thread.
-2. `Hibiki.error_handler = ->(error, effect) { ... }` — app-level routing
-   for effect errors raised during a flush (the gem does not set this).
-3. The graph worker's per-job rescue — everything unhandled lands in
-   `Rails.error.report(..., source: "hibiki_rails")`. Override per channel
-   via `build_graph_actor` and `GraphActor.new(on_error:)`.
+Documentation site: <https://planetaska.github.io/hibiki/rails-introduction/>
 
 ## Development
 
 ```
-bundle exec rake   # specs + rubocop (same as CI)
+bundle exec rake   # Ruby specs + rubocop
+bun install && bun run test   # the client's own specs
 ```
 
-The spec suite boots a minimal inline Rails app (`spec/support/dummy_app.rb`);
-the live end-to-end proof app is `spike/` in the parent repo.
+Both are what CI runs. The Ruby suite boots a minimal inline Rails app (`spec/support/dummy_app.rb`); the JS suite (`spec/js/`) drives the real Stimulus controller in happy-dom against a stubbed Action Cable consumer.
+
+The gem and the npm package are **released in lockstep**: `app/assets/javascripts/hibiki.js` is the single copy — the engine puts it on the asset path and `package.json` points `main`/`module`/`exports` at it — so importmap and bundler apps must never be able to resolve different client code. Bump `lib/hibiki/rails/version.rb` and `package.json` in the same commit, and publish both. The version table lives in [the JS client docs](https://planetaska.github.io/hibiki/the-js-client/).
+

data/app/assets/javascripts/hibiki.js

@@ -26,7 +26,9 @@
 //
 // Both shapes speak both transports. Transmit: the server's render
 // effects `transmit({ html: })` fragments that are swapped in by their
-// root DOM id; `received` is registered at subscribe time — before the
+// root DOM id, and `transmit_value` messages that update every
+// data-hibiki-value placeholder; `received` is registered at subscribe
+// time — before the
 // server runs build_graph — so the effects' first transmits always land
 // (the server-rendered initial HTML is only a paint-avoidance
 // placeholder). Turbo broadcasts: when the controller's element contains
@@ -42,8 +44,22 @@
 //   island root   data-controller="hibiki"
 //                 data-hibiki-channel-value="CounterChannel"
 //                 data-hibiki-cid-value="<per-page-load id>"
-//   controls      data-hibiki-on="<event>-><action>"   e.g. "click->increment"
+//                 data-hibiki-params-value='{"record_id":7}'  extra subscribe
+//                 params, merged UNDER channel/cid so they can't override them
+//   controls      data-hibiki-on="<event>-><action> ..."  whitespace-separated;
+//                 e.g. "click->load_more visible->load_more"
 //                 data-hibiki-with='{"index":3}'       optional JSON payload
+//                 data-hibiki-debounce="250"           ms to let the gesture settle
+//                 data-hibiki-confirm="Are you sure?"  window.confirm gate
+//                 data-hibiki-reset="false"            keep a submitted form's inputs
+//   value sites   data-hibiki-value="<name>"           reactive-value placeholder;
+//                 the server's transmit_value message updates every match
+//
+// The left side of `->` is a hibiki event name, of which DOM events are a
+// subset: click, change, input, submit are delegated listeners, and
+// `visible` is a pseudo-event backed by an IntersectionObserver (the
+// element entering the viewport). Everything that is not "which event"
+// is a sibling attribute, so the token grammar never has to grow.
 //
 // Register the generic controller under the identifier "hibiki" (the
 // helpers hardcode it):
@@ -61,6 +77,19 @@ let consumer
 // camelCase Stimulus method name → snake_case Ruby channel action.
 const underscore = (name) => name.replace(/([A-Z])/g, "_$1").toLowerCase()
 
+// What a changed control contributes to its action's payload. A checkbox's
+// `value` is its value ATTRIBUTE, not its state, so reading `value` made
+// checking and unchecking send byte-identical payloads; a multi-select's
+// `value` is only its first selected option. A radio needs no special case:
+// `change` fires on the newly-checked input, so `value` is already right.
+const controlValue = (control) => {
+  if (control.type === "checkbox") return control.checked
+  if (control.multiple && control.selectedOptions) {
+    return [...control.selectedOptions].map((option) => option.value)
+  }
+  return control.value
+}
+
 // The subclassable base: one channel subscription per controller element,
 // identified by a per-page-load cid (data-<identifier>-cid-value).
 export class ChannelController extends Controller {
@@ -78,26 +107,50 @@ export class ChannelController extends Controller {
     if (source) await streamConnected(source)
     if (this.aborted) return // disconnected during the await
     this.subscription = consumer.subscriptions.create(
-      { channel: this.channelName(), cid: this.cidValue },
+      this.subscribeParams(),
       { received: (data) => this.received(data) }
     )
   }
 
+  // What identifies this subscription to the server. Override to add
+  // params; keep channel/cid, which the Ruby side requires.
+  subscribeParams() {
+    return { channel: this.channelName(), cid: this.cidValue }
+  }
+
   disconnect() {
     this.aborted = true
     this.subscription?.unsubscribe()
     this.subscription = undefined
   }
 
-  // DOM → server: what declared action methods call.
+  // DOM → server: what declared action methods call. Optional chaining
+  // because a debounced action can fire after disconnect, and a sentinel
+  // can fire while connect is still awaiting its stream source.
   perform(action, payload = {}) {
-    this.subscription.perform(action, payload)
+    this.subscription?.perform(action, payload)
   }
 
-  // Server → DOM (transmit transport): swap each transmitted fragment in
-  // by its root id. Broadcast-transport channels never transmit, and a
-  // non-html transmit is not ours to interpret. Subclasses may override.
-  received({ html }) {
+  // Server → DOM (transmit transport). Two message shapes:
+  //
+  // { value: { name, text } } — a reactive value (transmit_value): write
+  // the text into every [data-hibiki-value=name] placeholder, document-
+  // wide (a value may render outside its island; names are page-unique).
+  // textContent assignment keeps values text-only and preserves each
+  // site's own tag/classes, so per-placeholder styling survives updates.
+  //
+  // { html } — a fragment: swap it in by its root id.
+  //
+  // Anything else is not ours to interpret. Subclasses may override, but
+  // should call super (or handle `value`) to keep reactive values live.
+  received({ html, value }) {
+    if (value) {
+      const selector = `[data-hibiki-value="${CSS.escape(value.name)}"]`
+      for (const site of document.querySelectorAll(selector)) {
+        site.textContent = value.text
+      }
+      return
+    }
     if (!html) return
     const template = document.createElement("template")
     template.innerHTML = html
@@ -157,57 +210,174 @@ export class ChannelController extends Controller {
 // The generic controller: adds the data-hibiki-* wire protocol on top of
 // the base's plumbing.
 export default class HibikiController extends ChannelController {
-  static values = { channel: String } // cid inherited from the base
+  // cid inherited from the base. `params` defaults to {} when the island
+  // stamps no data-hibiki-params-value.
+  static values = { channel: String, params: Object }
 
   // The island stamps its channel; no inference.
   channelName() {
     return this.channelValue
   }
 
+  // Extra subscribe params go UNDER channel/cid: they are client-supplied,
+  // so a page must not be able to point its subscription at another channel
+  // or steal another tab's graph by naming its cid. The server-side rule
+  // that goes with this is in Helpers#hibiki_island.
+  subscribeParams() {
+    return { ...this.paramsValue, ...super.subscribeParams() }
+  }
+
   async connect() {
     // Root-scoped delegation (bound to the island, not document): controls
     // inside server-replaced fragments keep working with no rebinding.
     // Set up synchronously so disconnect can always tear them down.
-    this.listeners = ["click", "change", "submit"].map((type) => {
+    this.listeners = ["click", "change", "input", "submit"].map((type) => {
       const handler = (event) => this.forward(event)
       this.element.addEventListener(type, handler)
       return [type, handler]
     })
+
+    // Debounce bookkeeping: a WeakMap keyed by control (so detached
+    // elements don't pin memory) plus a flat set of live timeouts, which is
+    // what disconnect can actually iterate.
+    this.timers = new WeakMap()
+    this.pending = new Set()
+
+    // `visible` is not a DOM event, so it needs its own observer beside the
+    // delegated listeners. Always on, never a pluggable module: an
+    // IntersectionObserver watching zero elements costs nothing at runtime,
+    // while an optional import brings back the failure mode where the
+    // attribute is present, the code isn't, and nothing errors.
+    this.observer = new IntersectionObserver((entries) => {
+      for (const entry of entries) {
+        if (!entry.isIntersecting) continue
+        // Fire once per observation. The re-scan after the next swap
+        // observes the REPLACEMENT element, and its fresh initial callback
+        // is what stops the classic "the new page didn't fill the viewport,
+        // so the loop stalls" trap.
+        this.observer.unobserve(entry.target)
+        this.dispatch(entry.target, { type: "visible", target: entry.target })
+      }
+    })
+
+    // Re-scan at the two points a fragment can be swapped under us, rather
+    // than blanket-observing the document: a MutationObserver over the page
+    // is a real per-mutation cost paid by every app on it.
+    this.streamRender = (event) => {
+      const render = event.detail.render
+      event.detail.render = async (streamElement) => {
+        await render(streamElement)
+        this.scanSentinels()
+      }
+    }
+    document.addEventListener("turbo:before-stream-render", this.streamRender)
+
     await super.connect()
+    if (this.aborted) return
+    this.scanSentinels()
   }
 
   disconnect() {
     for (const [type, handler] of this.listeners) {
       this.element.removeEventListener(type, handler)
     }
+    document.removeEventListener("turbo:before-stream-render", this.streamRender)
+    for (const id of this.pending) clearTimeout(id)
+    this.pending.clear()
+    this.observer.disconnect()
     super.disconnect()
   }
 
-  // DOM → server: forward a control's event as a channel action. Nested
-  // islands: events bubble to every ancestor island's listener, so each
-  // controller only acts when the control belongs to ITS island.
+  // The other swap point: hibiki's own transmit transport.
+  received(data) {
+    super.received(data)
+    if (data.html) this.scanSentinels()
+  }
+
+  // Observe every `visible->` sentinel this island owns. observe() is a
+  // no-op for an element already being observed, so re-scanning is cheap
+  // and cannot double-fire a sentinel that merely stayed put.
+  scanSentinels() {
+    for (const control of this.element.querySelectorAll('[data-hibiki-on*="visible->"]')) {
+      if (control.closest('[data-controller~="hibiki"]') === this.element) {
+        this.observer.observe(control)
+      }
+    }
+  }
+
+  // DOM → server: forward a control's event as a channel action.
   forward(event) {
     const control = event.target.closest("[data-hibiki-on]")
-    if (!control) return
+    if (control) this.dispatch(control, event)
+  }
+
+  // The shared path for both sources of events — the delegated DOM
+  // listeners and the visibility observer.
+  dispatch(control, event) {
+    // Nested islands: events bubble to every ancestor island's listener, so
+    // each controller only acts when the control belongs to ITS island.
     if (control.closest('[data-controller~="hibiki"]') !== this.element) return
 
     const token = control.dataset.hibikiOn
       .split(/\s+/)
       .find((t) => t.startsWith(`${event.type}->`))
     if (!token) return
-
     const action = token.slice(event.type.length + 2)
+
+    // Before the confirm, not after: declining must not let the form
+    // navigate away.
+    if (event.type === "submit") event.preventDefault()
+
+    const message = control.dataset.hibikiConfirm
+    if (message && !window.confirm(message)) return
+
+    // The payload is built when the action actually fires, so a debounced
+    // input sends what the user finished typing rather than the first
+    // keystroke that started the timer.
+    const wait = Number(control.dataset.hibikiDebounce)
+    const fire = () => this.send(control, event, action)
+    if (wait > 0) this.debounce(control, action, wait, fire)
+    else fire()
+  }
+
+  send(control, event, action) {
     const payload = control.dataset.hibikiWith
       ? JSON.parse(control.dataset.hibikiWith)
       : {}
     if (event.type === "submit") {
-      event.preventDefault()
       Object.assign(payload, Object.fromEntries(new FormData(control)))
-    } else if (event.type === "change" && control.name) {
-      payload[control.name] = control.value
+    } else if (control.name && (event.type === "change" || event.type === "input")) {
+      payload[control.name] = controlValue(control)
     }
     this.perform(action, payload)
-    if (event.type === "submit") control.reset()
+    // Resetting is right for an "add" form and wrong for an edit one: it
+    // runs synchronously, before the server has replied, so a failed commit
+    // would discard what the user typed.
+    if (event.type === "submit" && control.dataset.hibikiReset !== "false") {
+      control.reset()
+    }
+  }
+
+  // One timer per (control, action): two events on one element debounce
+  // independently, and a second control's typing never cancels the first's.
+  debounce(control, action, wait, fire) {
+    let byAction = this.timers.get(control)
+    if (!byAction) {
+      byAction = new Map()
+      this.timers.set(control, byAction)
+    }
+    const previous = byAction.get(action)
+    if (previous) {
+      clearTimeout(previous)
+      this.pending.delete(previous)
+    }
+    const id = setTimeout(() => {
+      byAction.delete(action)
+      this.pending.delete(id)
+      fire()
+    }, wait)
+    byAction.set(action, id)
+    this.pending.add(id)
   }
 }
 

data/lib/generators/hibiki/rails/phlex/phlex_generator.rb

@@ -49,7 +49,7 @@ module Hibiki
 
             Render it from any page:
 
-              <%= render #{class_name}Island.new %>
+              <%= render Components::#{class_name}Island.new %>
 
           MSG
           register_hint

data/lib/generators/hibiki/rails/phlex/templates/channel.rb.tt

@@ -8,7 +8,7 @@ class <%= class_name %>Channel < ApplicationCable::Channel
   include Hibiki::Rails::Channel
 
   def build_graph
-    @component = <%= class_name %>.new
+    @component = Components::<%= class_name %>.new
 
     # First run is the dependency-collecting initial render.
     Hibiki::Phlex.render_effect(@component) { |html| transmit({ html: }) }

data/lib/generators/hibiki/rails/phlex/templates/component.rb.tt

@@ -5,7 +5,7 @@
 # read as ordinary method calls (no .value anywhere), Rerenderable lets
 # the channel's render effect re-render this same instance, and Helpers
 # stamps the client's wire protocol.
-class <%= class_name %> < Phlex::HTML
+class Components::<%= class_name %> < Phlex::HTML
   include Hibiki::Reactive
   include Hibiki::Phlex::Rerenderable
   include Hibiki::Rails::Helpers

data/lib/generators/hibiki/rails/phlex/templates/island_component.rb.tt

@@ -3,15 +3,15 @@
 # The island wrapper: one channel subscription per render, identified by
 # a per-page-load cid. Render from any page:
 #
-#   <%%= render <%= class_name %>Island.new %>
-class <%= class_name %>Island < Phlex::HTML
+#   <%%= render Components::<%= class_name %>Island.new %>
+class Components::<%= class_name %>Island < Phlex::HTML
   include Hibiki::Rails::Helpers
 
   def view_template
     div(**hibiki_island(<%= class_name %>Channel, cid: SecureRandom.uuid)) do
       # A throwaway instance as a paint-avoidance placeholder; the
       # channel's long-lived instance takes over from its first transmit.
-      render <%= class_name %>.new
+      render Components::<%= class_name %>.new
     end
   end
 end

data/lib/hibiki/rails/channel.rb

@@ -36,13 +36,23 @@ module Hibiki
       end
 
       module ClassMethods
-        private
+        # Lifecycle hooks, never client-invocable actions. Performing
+        # "build_graph" would rebuild the graph and leak the old root;
+        # "subscribed" would build a SECOND graph actor on the connection.
+        #
+        # These need subtracting because ActionCable computes action_methods
+        # as "public methods this class adds": #subscribed and #unsubscribed
+        # are private on its base class, so they are never subtracted for
+        # free, and a public app-side override — the shape the ActiveRecord
+        # guide's after_commit bridge invites — is added straight back by
+        # public_instance_methods(false).
+        HIDDEN_ACTIONS = %w[build_graph subscribed unsubscribed].freeze
 
-        # #build_graph is a lifecycle hook, not a client-invocable action:
-        # keep it out of action_methods even when an app defines it public
-        # (a client performing "build_graph" would rebuild the graph and
-        # leak the old root).
-        def internal_methods = super + [:build_graph]
+        # Subtracted here rather than through ActionCable's #internal_methods
+        # hook, which only exists on 8.x: on Rails 7.1 and 7.2 that hook is
+        # never consulted, so an override of it is silently dead code. This
+        # works on every supported version.
+        def action_methods = super - HIDDEN_ACTIONS
       end
 
       # ActionCable's single dispatch point for incoming actions. The whole
@@ -92,6 +102,39 @@ module Hibiki
         raise NotImplementedError, "#{self.class} must implement #build_graph"
       end
 
+      # The channel half of a single reactive value (see Helpers#reactive for
+      # the placeholder half): wraps the block in an effect that transmits
+      # `{ value: { name:, text: } }` — the packaged client writes the text
+      # into every `[data-hibiki-value=NAME]` placeholder on the page (part
+      # of the data-hibiki wire contract, versioned with the client). Call
+      # from #build_graph; the block tracks whatever signals it reads (state,
+      # derived, or an expression over several). Values are text, never
+      # markup: the client assigns textContent, so nothing is interpreted as
+      # HTML. Returns the effect, owned by the graph root like any other.
+      #
+      # Equality-gated: an effect re-runs whenever ANY signal it read
+      # changed, so a bumped db_version re-sent every value's text even when
+      # the text was byte-identical — once per reactive value, per ping.
+      # The block is still called unconditionally, so dependency collection
+      # is untouched; only the transmit is skipped.
+      #
+      # NOTE for placeholders rendered INSIDE a broadcast-replaced fragment:
+      # render them with their CURRENT value, not a static default. The swap
+      # resets the DOM text, and this gate now suppresses the re-send that
+      # used to heal it. Placeholders outside the replaced fragment (a nav
+      # badge, controls that are never re-rendered) are unaffected.
+      def transmit_value(name, &compute)
+        name = Helpers.value_name(name)
+        last = Object.new # never == a String, so the first run always sends
+        Hibiki::Effect.new do
+          text = compute.call.to_s
+          unless text == last
+            last = text
+            transmit({ value: { name:, text: } })
+          end
+        end
+      end
+
       # Per-page-load graph identity, supplied by the page's subscription
       # (each tab is its own graph). Override to derive identity elsewhere.
       def cid = params[:cid]

data/lib/hibiki/rails/graph_actor.rb

@@ -46,9 +46,23 @@ module Hibiki
 
       # Per-job rescue keeps the worker alive: one bad action must not take
       # the whole graph down. StandardError only — an Interrupt should.
+      #
+      # Each job is one unit of work in the Rails sense, so it runs inside
+      # the executor: CurrentAttributes reset between jobs (state must not
+      # leak from one action to the next on a long-lived graph thread),
+      # Zeitwerk's permit_concurrent_loads around autoloads off the main
+      # thread, an AR query cache per job, and reloader participation.
+      #
+      # The rescue sits INSIDE the wrap deliberately. ExecutionWrapper.wrap
+      # reports anything that escapes it to Rails.error itself — handled:
+      # false, source "application.active_support" — and then re-raises, so
+      # rescuing outside would report every graph error twice, once as
+      # unhandled. Rescuing inside means @on_error stays the single sink for
+      # a StandardError; a non-StandardError still escapes the wrap and takes
+      # the worker down, exactly as before.
       def work
         while (job = @queue.pop)
-          begin
+          ::Rails.application.executor.wrap do
             job.call
           rescue StandardError => e
             @on_error.call(e)

data/lib/hibiki/rails/helpers.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "cgi/escape"
 require "json"
 
 module Hibiki
@@ -14,7 +15,10 @@ module Hibiki
     #     button(**on(:increment)) { "+" }
     #     button(**on(:toggle, with: { index: 3 })) { "toggle" }
     #     input(name: "step", **on(:set_step, event: :change))
-    #     form(**on(:add, event: :submit)) { ... }
+    #     input(name: "q", **on(:search, event: :input))
+    #     button(**on(:destroy, confirm: "Are you sure?")) { "delete" }
+    #     button(**on(:load_more, event: %i[click visible])) { "more" }
+    #     form(**on(:save, event: :submit, reset: false)) { ... }
     #   end
     #
     # Both helpers return a `{ data: { ... } }` hash: splat it into Phlex
@@ -25,25 +29,156 @@ module Hibiki
     # The emitted attribute names are a private contract between these
     # helpers and the gem's JS — they version together; don't hand-write
     # them in app code.
+    #
+    # #reactive is the exception to the splat shape: it returns a complete
+    # placeholder element (`<%= reactive :doubled, 0 %>` in ERB). Phlex
+    # components splat instead: `span(**reactive_attrs(:doubled))`.
     module Helpers
+      # A reactive value's name lands in an attribute selector on both
+      # halves, so keep it to safe characters; the placeholder tag name
+      # lands in raw markup, so allowlist it too.
+      VALUE_NAME = /\A[a-z][a-z0-9_-]*\z/i
+      VALUE_TAG = /\A[a-z][a-z0-9-]*\z/i
+
+      # Event and action names share the hibiki_on attribute, which is a
+      # whitespace-separated token list — a name carrying a space or an
+      # arrow would silently change what the client dispatches. The dot is
+      # allowed so a future event qualifier (keydown.enter) needs no second
+      # grammar change.
+      EVENT_NAME = /\A[a-z][a-z0-9_.-]*\z/i
+
+      # Per-keystroke round trips are the failure mode #on exists to avoid,
+      # so :input carries a debounce unless the caller says otherwise. It is
+      # applied here rather than in the client, so the number is visible in
+      # the emitted markup instead of being an invisible default.
+      DEFAULT_INPUT_DEBOUNCE = 250
+
+      private_constant :VALUE_NAME, :VALUE_TAG, :EVENT_NAME
+
+      # The shared name validator for both halves of a reactive value (the
+      # view-side data-hibiki-value placeholder and the channel's
+      # #transmit_value message).
+      def self.value_name(name)
+        name = name.to_s
+        unless VALUE_NAME.match?(name)
+          raise ArgumentError,
+                "reactive value name #{name.inspect} must match #{VALUE_NAME.inspect}"
+        end
+        name
+      end
+
+      # The shared validator for both halves of an `event->action` token.
+      def self.event_name(name)
+        name = name.to_s
+        unless EVENT_NAME.match?(name)
+          raise ArgumentError,
+                "event or action name #{name.inspect} must match #{EVENT_NAME.inspect}"
+        end
+        name
+      end
+
       # The island root: one channel subscription per island, identified by
       # a per-page-load cid (each tab is its own graph). `channel` is the
       # channel class or its name as a string.
-      def hibiki_island(channel, cid:)
+      #
+      # `params:` is a hash of extra subscribe params, reaching the channel
+      # as `params[:key]` beside `cid`. It is how a channel learns WHICH
+      # record its page is about (a show page's `record_id`), which is
+      # otherwise unexpressible — the subscription is the only server-side
+      # hook that runs before the graph is built.
+      #
+      # THE TRUST RULE. Subscribe params are client-supplied and untrusted,
+      # exactly like query params on a request: anyone can open a socket and
+      # send whatever they like. A channel may use one only to LOOK UP A
+      # RECORD INSIDE A SCOPE IT CHOOSES ITSELF —
+      # `current_user.books.find(params[:record_id])` — and must `reject`
+      # when the lookup fails. It must never interpolate a param into a
+      # streamable name, a class name, a column name, or a scope. The
+      # streamable a channel streams from is always derived server-side from
+      # the record it has already loaded and authorized. The client cannot
+      # override `channel` or `cid` through this hash.
+      def hibiki_island(channel, cid:, params: nil)
         channel_name = channel.is_a?(Class) ? channel.name : channel.to_s
-        { data: { controller: "hibiki", hibiki_channel_value: channel_name,
-                  hibiki_cid_value: cid } }
+        data = { controller: "hibiki", hibiki_channel_value: channel_name,
+                 hibiki_cid_value: cid }
+        data[:hibiki_params_value] = JSON.generate(params) unless params.nil?
+        { data: }
       end
 
-      # Forward a DOM event on this element as a channel action. `event:`
-      # picks the DOM event (:click, :change, :submit); `with:` is a hash
-      # sent as the action's payload. The client adds event-derived data on
-      # top: a changed control contributes `{ name => value }`, a submitted
-      # form contributes its FormData (and is reset after the perform).
-      def on(action, event: :click, with: nil)
-        data = { hibiki_on: "#{event}->#{action}" }
-        data[:hibiki_with] = JSON.generate(with) unless with.nil?
-        { data: }
+      # Forward an event on this element as a channel action.
+      #
+      # `event:` names the event, or a list of them — the left side of the
+      # `->` is a hibiki event name, of which DOM events are a subset:
+      # :click, :change, :input, :submit, plus the :visible pseudo-event
+      # (an IntersectionObserver sentinel — the element entering the
+      # viewport). A list makes one element answer several, which is how a
+      # load-more button doubles as an infinite-scroll sentinel:
+      #
+      #   on(:load_more, event: %i[click visible], with: { shown: rows.size })
+      #
+      # `with:` is a hash sent as the action's payload. The client adds
+      # event-derived data on top: a changed control contributes
+      # `{ name => value }` — a checkbox its checked state, a multi-select
+      # its selected values — and a submitted form contributes its FormData.
+      #
+      # Everything else is a per-control modifier, kept out of the token
+      # grammar so the `->` left side stays purely "which event":
+      #
+      #   debounce: ms  wait for the gesture to settle before performing.
+      #                 :input defaults to DEFAULT_INPUT_DEBOUNCE; pass 0 to
+      #                 send every keystroke.
+      #   confirm: msg  window.confirm before performing; declining performs
+      #                 nothing (and does not submit the form).
+      #   reset: false  keep a submitted form's inputs. The default resets
+      #                 them, which is right for an "add" form and wrong for
+      #                 an edit one — a failed commit would otherwise discard
+      #                 what the user typed, synchronously, before the server
+      #                 has even replied.
+      def on(action, event: :click, with: nil, debounce: nil, confirm: nil, reset: nil)
+        action = Helpers.event_name(action)
+        events = Array(event).map { Helpers.event_name(it) }
+        debounce = DEFAULT_INPUT_DEBOUNCE if debounce.nil? && events.include?("input")
+        tokens = events.map { "#{it}->#{action}" }.join(" ")
+        { data: { hibiki_on: tokens }
+            .merge(on_modifiers(with:, debounce:, confirm:, reset:)) }
+      end
+
+      # Placeholder for a single reactive value: `<%= reactive :doubled, 0 %>`
+      # paints `<span data-hibiki-value="doubled">0</span>`; the channel's
+      # `transmit_value(:doubled) { ... }` keeps it fresh. The same value may
+      # be placed any number of times, anywhere on the page — every
+      # placeholder updates (the client matches document-wide, so a value can
+      # render outside its island too). Names must be page-unique across
+      # channels. Only the placeholder text is server-rendered: each site
+      # keeps its own tag, classes, and attributes across updates.
+      def reactive(name, placeholder = "", tag_name: :span)
+        tag_name = tag_name.to_s
+        unless VALUE_TAG.match?(tag_name)
+          raise ArgumentError,
+                "reactive value tag #{tag_name.inspect} must match #{VALUE_TAG.inspect}"
+        end
+        html = %(<#{tag_name} data-hibiki-value="#{Helpers.value_name(name)}">) +
+               %(#{CGI.escapeHTML(placeholder.to_s)}</#{tag_name}>)
+        html.respond_to?(:html_safe) ? html.html_safe : html
+      end
+
+      # The value's attributes, for stamping the placeholder yourself — the
+      # Phlex form of #reactive: `span(**reactive_attrs(:doubled)) { "0" }`.
+      def reactive_attrs(name) = { data: { hibiki_value: Helpers.value_name(name) } }
+
+      private
+
+      # #on's per-control modifiers, kept out of the token grammar. Each is
+      # omitted when it matches the client's own default, so the common call
+      # still stamps exactly one attribute.
+      def on_modifiers(with:, debounce:, confirm:, reset:)
+        debounce = Integer(debounce) if debounce
+        {
+          hibiki_with: (JSON.generate(with) unless with.nil?),
+          hibiki_debounce: (debounce unless debounce.nil? || debounce.zero?),
+          hibiki_confirm: confirm&.to_s,
+          hibiki_reset: ("false" if reset == false)
+        }.compact
       end
     end
   end

data/lib/hibiki/rails/reactive_form.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module Hibiki
+  module Rails
+    # A reactive form object over one ActiveRecord record: hydrate its
+    # attributes into signals at one edge, work reactively in the middle,
+    # commit back at the other. The record itself never enters the graph.
+    #
+    #   class TodoForm
+    #     include Hibiki::Rails::ReactiveForm
+    #
+    #     reactive_attributes Todo, :title, :done
+    #
+    #     derived(:title_error) { "can't be blank" if title.strip.empty? }
+    #     derived(:valid?)      { title_error.nil? }
+    #   end
+    #
+    #   form = TodoForm.from(Todo.find(id))   # or Todo.new — see below
+    #   form.title = "buy milk"               # a plain signal write
+    #   form.dirty?                           # => true
+    #   form.commit                           # => false if invalid
+    #   form.error_for(:title)                # => the model's own message
+    #
+    # One form class serves create AND update, the `form_with model:`
+    # convention: `from(Todo.new)` hydrates the column defaults and `commit`
+    # on an unpersisted record INSERTs, so create-vs-update is invisible to
+    # the caller. `dirty?` on a create form means "changed from the
+    # defaults" — exactly what enables a Create button.
+    #
+    # Two layers of validation, deliberately: hand-written deriveds give
+    # per-keystroke feedback (hand-picked, like client-side validation),
+    # while the model's own `validates` stay authoritative at commit and
+    # land in #errors. Nothing here names an ActiveRecord constant — the
+    # record is duck-typed (readers, #update, #save!, #errors,
+    # #persisted?) — but the casting below is AR's attribute API, which is
+    # why this lives in the Rails glue gem and not in the core.
+    module ReactiveForm
+      def self.included(base)
+        base.include(Hibiki::Reactive)
+        base.extend(ClassMethods)
+        # One derived over the whole attribute set rather than per-field
+        # change tracking: cheap, and enough for "enable the save button".
+        base.derived(:dirty?) { to_h != __hibiki_snapshot.value }
+      end
+
+      module ClassMethods
+        # Hydrate from a record — the only supported constructor. Extra
+        # arguments are forwarded to #initialize, so a form with its own
+        # constructor still works.
+        def from(record, ...) = new(...).hydrate(record)
+
+        # reactive_attributes Todo, :title, :done
+        #
+        # The model may be a Class or a String/Symbol; a name is resolved on
+        # every use, so a form class under app/ never pins a constant across
+        # a Zeitwerk reload.
+        def reactive_attributes(model, *names)
+          @hibiki_model = model
+          @hibiki_attributes = names.map(&:to_sym)
+          casts = __hibiki_casts
+          @hibiki_attributes.each do |name|
+            state name
+            casts.define_method(:"#{name}=") { |value| super(self.class.hibiki_type(name).cast(value)) }
+          end
+        end
+
+        def hibiki_attributes
+          @hibiki_attributes || __hibiki_inherited(:hibiki_attributes) || []
+        end
+
+        def hibiki_model
+          model = @hibiki_model || __hibiki_inherited(:hibiki_model)
+          raise "#{self} has no reactive_attributes declaration" if model.nil?
+
+          model.is_a?(Module) ? model : model.to_s.constantize
+        end
+
+        # Channel action params arrive as strings; casting through the
+        # model's own attribute type is the difference between
+        # `done = "false"` meaning false and meaning true.
+        def hibiki_type(name) = hibiki_model.type_for_attribute(name.to_s)
+
+        private
+
+        # Declarations live in class ivars, so subclasses have to walk up
+        # for them — the generated methods inherit on their own.
+        def __hibiki_inherited(reader)
+          superclass.public_send(reader) if superclass.respond_to?(reader)
+        end
+
+        # One module per class, prepended once: the casting writer wraps
+        # the writer `state` defined on the class itself (via super)
+        # instead of replacing it.
+        def __hibiki_casts = @__hibiki_casts ||= Module.new.tap { prepend(it) }
+      end
+
+      # The record, held in a plain ivar and NEVER in a signal: it is the
+      # boundary, touched only by #hydrate and #commit.
+      attr_reader :record
+
+      # Also the "reset from a reloaded record" path. One batch, so a
+      # re-hydrate is one effect run rather than one per attribute.
+      def hydrate(record)
+        @record = record
+        Hibiki.batch do
+          self.class.hibiki_attributes.each { |name| public_send(:"#{name}=", record.public_send(name)) }
+          __hibiki_snapshot.value = to_h
+          __hibiki_errors.value = {}
+        end
+        self
+      end
+
+      def persisted? = record&.persisted? || false
+
+      # Reads every attribute signal, so anything derived from it tracks
+      # them all.
+      def to_h = self.class.hibiki_attributes.to_h { |name| [name, public_send(name)] }
+
+      # Write the record. Returns false and mirrors the model's errors into
+      # #errors when validation fails (the Rails #save convention). On
+      # success the form re-hydrates: callbacks and database defaults may
+      # have moved values, and #persisted? flips after an INSERT.
+      # rubocop:disable Naming/PredicateMethod -- boolean without a ?, exactly like AR's #save
+      def commit
+        record = __hibiki_record!
+        if record.update(**to_h)
+          hydrate(record)
+          true
+        else
+          __hibiki_errors.value = record.errors.to_hash
+          false
+        end
+      end
+      # rubocop:enable Naming/PredicateMethod
+
+      # The raising half. #commit has already assigned the attributes and
+      # mirrored the errors, so #save! re-validates the same record and
+      # raises ActiveRecord::RecordInvalid — no rescue, and no AR constant
+      # named here.
+      def commit! = commit || __hibiki_record!.save!
+
+      # { title: ["can't be blank"] } — mirrored at a failed commit,
+      # cleared at a successful one. Reactive like any other signal read:
+      # an effect over #error_for repaints when a commit fails.
+      def errors = __hibiki_errors.value
+
+      def error_for(name) = errors[name.to_sym]&.first
+
+      private
+
+      # Snapshot and errors are plain States rather than `state` macros on
+      # purpose: the macro would generate public writers and invite writes
+      # that bypass #hydrate and #commit.
+      def __hibiki_snapshot = @__hibiki_snapshot ||= Hibiki::State.new({})
+
+      def __hibiki_errors = @__hibiki_errors ||= Hibiki::State.new({})
+
+      def __hibiki_record!
+        record || raise("#{self.class} has no record — build it with .from(record)")
+      end
+    end
+  end
+end

data/lib/hibiki/rails/version.rb

@@ -2,6 +2,6 @@
 
 module Hibiki
   module Rails
-    VERSION = "0.1.0"
+    VERSION = "0.3.0"
   end
 end

data/lib/hibiki/rails.rb

@@ -12,8 +12,25 @@ module Hibiki
     # This is the outer layer of the funnel — a flush error first goes to
     # an app-set Hibiki.error_handler if there is one, and only re-raises
     # into the actor's per-job rescue when there isn't.
+    #
+    # It ALSO logs, in local environments only. ActiveSupport::ErrorReporter
+    # has no subscribers by default, so report alone means a graph-thread
+    # exception vanishes completely in a stock app: no log line, no stack,
+    # and the only symptom is a fragment that stops updating. That cost real
+    # debugging time while the CRUD reference app was built. `local?` is
+    # development + test, so production apps — which do have a subscriber —
+    # get no duplicate line. Swap the whole thing per graph via
+    # GraphActor.new(on_error:) if you want different behaviour.
     def self.default_error_reporter
-      ->(error) { ::Rails.error.report(error, handled: true, source: "hibiki_rails") }
+      lambda do |error|
+        if ::Rails.env.local? && ::Rails.logger
+          ::Rails.logger.error(
+            "[hibiki_rails] #{error.class}: #{error.message}\n" \
+            "#{Array(error.backtrace).first(20).join("\n")}"
+          )
+        end
+        ::Rails.error.report(error, handled: true, source: "hibiki_rails")
+      end
     end
   end
 end
@@ -25,4 +42,5 @@ require_relative "rails/debounce"
 require_relative "rails/broadcasts"
 require_relative "rails/channel"
 require_relative "rails/helpers"
+require_relative "rails/reactive_form"
 require_relative "rails/engine"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hibiki_rails
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - planetaska
@@ -102,6 +102,7 @@ files:
 - lib/hibiki/rails/engine.rb
 - lib/hibiki/rails/graph_actor.rb
 - lib/hibiki/rails/helpers.rb
+- lib/hibiki/rails/reactive_form.rb
 - lib/hibiki/rails/registry.rb
 - lib/hibiki/rails/version.rb
 - lib/hibiki_rails.rb