phlex-reactive 0.2.8 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9b321b7411a892ec63333f9d85d988f7cf63609601386a03593efd736e88fb42
-  data.tar.gz: 00d40c394774eb54af634d328251f646a3fae1ac9bc0413ccbc89dd863608001
+  metadata.gz: 7232501319d17c45c8907195117f5af59d8b7a4ff9c8d5efb2c0c8248350041e
+  data.tar.gz: 783cd0758a5a51cead67f6f1ea2c8bf23245f62e49a38ea0831328b68b9d0b2c
 SHA512:
-  metadata.gz: bd7a2129ec09c6b33a9f623f201037f5bc6639f7b097c95f521a6bf7ba4999b8dc8e11f53f2b922f5e617d0dfd8e2b0185cc5676e20f040a9caf97637d2d9438
-  data.tar.gz: b6e611eab9a2ab3f3d3a6afff9c4780061ba07321ddb5db89970e076facc9d7a374f7809fe8bc38958040c34303a42484eefe25109495bdfb2b6f894a597ae3e
+  metadata.gz: a673a7253c99e7b6fccb5228014a47d2918cda2995de79afdb6545adb89a8af8ab99812569455bc7f206c12d7c7efb710ff90d628d767da012ba5deb690e5ab7
+  data.tar.gz: cf68ac7ff60925c73aa0de543665b60d85d8254bada63a40c1786a6a3e7ee3bfceaad123c91daf2f7fec18de8aab04ab61d2ee165b5e0ad241b451ce60c24769

data/CHANGELOG.md

@@ -8,6 +8,77 @@ adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ### Added
 
+- **`reply.streams` — partial update with a token-only refresh (issue #30).**
+  `reply.streams(Totals.update(@item))` emits **exactly** the streams you pass —
+  no forced full-self replace — so an action can re-render only part of a
+  component (one total cell, one sub-region) while the rest of the DOM, including
+  a sibling `<input>` the user is mid-typing in, is left untouched. The signed
+  identity token still rolls forward: the endpoint appends a tiny
+  `<turbo-stream action="reactive:token">` (new `Streamable#to_stream_token`) that
+  carries the fresh `data-reactive-token-value` and is applied by an inert client
+  action — a pure attribute write on the root, so the focused field + caret
+  survive. This unblocks spreadsheet-like per-field grid editing that the old
+  "every reply re-renders the whole component" behavior made unusable (you had to
+  reach for `data-turbo-permanent`). `Response.streams(self, *)` is the underlying
+  builder; `reply.streams(*)` is the bound form. Backed by a new `render_self:
+  false` + `token_component` path in the endpoint — the legacy full-self-replace
+  refresh (`reply.replace` / `reply.with`) is unchanged.
+
+- **`reply` — the action-reply builder.** Control an action's reply with
+  `reply.replace` / `reply.morph` / `reply.update` / `reply.remove` /
+  `reply.redirect(url)` / `reply.with(*)`, chaining `.flash` / `.stream` /
+  `.also_update` / `.also_replace` as before. `reply` is a subject-bound facade on
+  the component, so the two warts of the old form disappear: no `self` to thread
+  (`reply.morph`, not `Response.morph(self)`) and no constant to qualify — a
+  namespaced component no longer needs a per-file `Response = …` alias, because
+  `reply` is a method resolved on the component, not a lexical constant. It
+  returns the same immutable value object the endpoint reads, so the return-value
+  contract, immutability, and chaining are unchanged. `Phlex::Reactive::Response`
+  remains fully functional but is now an internal detail — `reply` is the
+  documented surface.
+
+- **Morph response — focus-preserving re-render (issue #28).**
+  `reply.morph` (and the opt-in `reply.replace(morph: true)`)
+  re-renders a component in place via Turbo 8's bundled Idiomorph
+  (`<turbo-stream action="replace" method="morph">`) instead of an outerHTML
+  swap. The focused `<input>` and its caret survive the save, making per-field
+  reactive editing — a "spreadsheet" grid where a debounced save fires while the
+  user is still typing/tabbing — actually viable. Backed by the new
+  `Streamable#to_stream_morph` primitive and a `morph:` flag on the
+  `.replace` / `.broadcast_replace_to` class builders and `#also_replace`
+  (live cross-tab updates can morph too). The default everywhere stays the plain
+  replace (no `method="morph"` attribute), so existing components are unchanged.
+  No new dependency — Idiomorph ships with `turbo-rails >= 2.0`.
+- **Input/select param-binding helpers (issue #23).** `reactive_input(:value,
+  …)` and `reactive_select(:status, …) { … }` render a form control already bound
+  to an action param — no hand-written `name: "value"` magic string to forget
+  (which silently leaves the action with no params). `reactive_field(:param,
+  **attrs)` returns just the attribute hash to spread onto any control; an
+  explicit `name:` still wins as an escape hatch. The trigger stays on the
+  button, so focusing the field doesn't dispatch and collapse edit mode.
+- **`accepts_nested_attributes_for` helper (issue #24).** `nested_update!(:address,
+  address)` maps a declared nested param straight onto `<assoc>_attributes` and
+  carries the existing associated record's id, so `update_only:` matches it in
+  place instead of building a second `has_one` — replacing the per-editor
+  `*_attributes` + id-preservation boilerplate that was easy to get subtly wrong.
+  `nested_attributes(:address, address)` returns the id-merged hash without
+  updating, for combining with other attributes.
+- **`Response#also_update` / `#also_replace` (issue #25).** Re-render a companion
+  element alongside self without dropping to raw `turbo_stream_builder`:
+  `Response.replace(self).also_update("page_heading", html: @record.name)` adds an
+  update stream for an arbitrary DOM id (`html` is a string or a Phlex component,
+  rendered through the configured renderer), and `.also_replace(other_component)`
+  re-renders another Streamable component targeting its own `#id`. Both are
+  immutable and additive, so the self-replace still refreshes the signed token.
+- **Boot-time integration guards (issue #26).** Two silent first-run failures now
+  surface a clear warning. A host catch-all route (`match "*path", …`) that
+  shadows the engine's appended `POST /reactive/actions` (every reactive POST
+  404s) is detected at boot via a route-recognition check
+  (`Phlex::Reactive.action_route_ok?`), logging how to exempt the path. And when
+  `data-controller="reactive"` elements are on the page but no controller
+  connected — the `lazyLoadControllersFrom` case where the gem's controller was
+  never registered — the client runtime logs a console warning naming the fix.
+  The README gains an "Integration troubleshooting" section covering both.
 - **Nested & array param types (issue #16).** Action param schemas can now
   declare arrays and nested hashes, not just scalars: wrap a type in an array
   (`bank_account_ids: [:integer]`) for an array param, or wrap a hash schema in

data/README.md

@@ -124,7 +124,7 @@ Import and register it from your controllers entrypoint:
 
 ```js
 import { application } from "./application"
-import ReactiveController from "phlex-reactive/reactive_controller"
+import ReactiveController from "phlex/reactive/reactive_controller"
 application.register("reactive", ReactiveController)
 ```
 
@@ -137,6 +137,47 @@ gem; point your bundler at the gem path or copy it in. See
 and a Phlex `ApplicationComponent` base class. pgbus is optional but recommended
 for broadcasting.
 
+### Integration troubleshooting (silent "nothing happens")
+
+Two host-app setups make the first reactive component *silently do nothing* —
+components render, but no action ever fires, with no error pointing at the cause.
+The gem now logs a warning for each, but here are the fixes:
+
+**A catch-all route shadows `POST /reactive/actions`.** The engine appends its
+route *after* everything in your `config/routes.rb`, so a bottom-of-file
+catch-all wins and every reactive POST 404s:
+
+```ruby
+# config/routes.rb — a catch-all like this shadows the engine's appended route
+match "*path", to: "errors#not_found", via: :all
+```
+
+Exempt the reactive path from the catch-all (or set
+`Phlex::Reactive.action_path` to an unshadowed path):
+
+```ruby
+match "*path", to: "errors#not_found", via: :all,
+  constraints: ->(req) { !req.path.start_with?("/reactive/") }
+```
+
+At boot the gem warns (`[phlex-reactive] POST /reactive/actions does not resolve
+to phlex/reactive/actions …`) when the route is shadowed.
+
+**The `reactive` controller isn't registered (`lazyLoadControllersFrom` apps).**
+`lazyLoadControllersFrom("controllers", application)` only registers controllers
+under `app/javascript/controllers/`. The gem's controller lives outside that dir,
+so `data-controller="reactive"` does nothing until you register it explicitly:
+
+```js
+// app/javascript/controllers/index.js (or your Stimulus entrypoint)
+import ReactiveController from "phlex/reactive/reactive_controller"
+application.register("reactive", ReactiveController)
+```
+
+If reactive elements are on the page but the controller never connected, the
+runtime logs a console warning (`[phlex-reactive] found N element(s) with
+data-controller="reactive" but the reactive controller never connected …`).
+
 ---
 
 ## The mental model in one picture
@@ -150,8 +191,8 @@ for broadcasting.
    │                                          rebuild component (record from DB)
    │                                          run the whitelisted action
    │                                          re-render → <turbo-stream replace id>   (default; an action
-   │                                          may return a Response — see "Controlling the action's reply")
-   └──────── Turbo morphs it in ◀───────────────────────────────┘
+   │                                          may return reply.<verb> — see "Controlling the action's reply")
+   └──────── Turbo applies it in ◀──────────────────────────────┘
 
    ...and for OTHER tabs/users:
    model change → Component.broadcast_replace_to(stream) → pgbus SSE → same morph
@@ -251,11 +292,11 @@ The cross-tab chat in ~60 lines of Ruby (and zero JS) is the showcase — see
 | Method | Use |
 |---|---|
 | `#id` (you implement) | Stable DOM id == Turbo Stream target. Must match the root element's `id`. |
-| `.replace(model = nil, **opts)` | `<turbo-stream action=replace target=id>` of a freshly built component |
+| `.replace(model = nil, morph: false, **opts)` | `<turbo-stream action=replace target=id>` of a freshly built component; `morph: true` adds `method="morph"` |
 | `.update` / `.append(target:)` / `.prepend(target:)` / `.remove` | The other Turbo Stream actions |
-| `.broadcast_replace_to(*streamables, model:)` | Broadcast a replace over the stream transport (pgbus SSE / Action Cable) |
+| `.broadcast_replace_to(*streamables, model:, morph: false)` | Broadcast a replace over the stream transport (pgbus SSE / Action Cable); `morph: true` morphs in place |
 | `.broadcast_append_to(*streamables, target:, model:)` / `_update_` / `_prepend_` / `_remove_` | The broadcast variants |
-| `#to_stream_replace` / `#to_stream_update` / `#to_stream_remove` | Stream the *already-built* instance (used internally after an action / by `Response`) |
+| `#to_stream_replace` / `#to_stream_morph` / `#to_stream_update` / `#to_stream_remove` | Stream the *already-built* instance (used internally after an action / by `reply`); `#to_stream_morph` morphs in place |
 
 Use in controllers: `render turbo_stream: Counter.replace(counter)`.
 
@@ -269,6 +310,10 @@ Use in controllers: `render turbo_stream: Counter.replace(counter)`.
 | `reactive_attrs` | Spread onto the root element: marks it reactive + carries the signed token. |
 | `on(:action, event: "click", **params)` | Spread onto a trigger element. Adds `type=button` for clicks. |
 | `on(:action, event: "input", debounce: 300)` | Coalesce rapid events into one round trip after a quiet period (live-as-you-type). |
+| `reactive_input(:param, **attrs)` / `reactive_select(:param, **attrs)` | Render a control already bound to an action param (no magic `name:`). |
+| `reactive_field(:param, **attrs)` | The attribute hash behind the above — spread onto any control. |
+| `nested_update!(:assoc, attrs)` | Map a nested param onto `<assoc>_attributes` with id preservation; update the record. |
+| `reply.replace` / `.morph` / `.update` / `.remove` / `.redirect(url)` / `.with(*)` | Return from an action to control the reply (flash, remove, redirect, multi-stream). See [Controlling the action's reply](#reply--controlling-the-actions-reply). |
 
 Param types: `:string` (default), `:integer`, `:float`, `:boolean`. Anything not
 in the schema is dropped before reaching your method.
@@ -337,40 +382,114 @@ div(**mix(reactive_attrs, id:, class: "card")) { ... }
 button(**on(:increment), data: { testid: "inc" }) { "+" }
 ```
 
-### `Phlex::Reactive::Response` — controlling the action's reply
+**Binding inputs to action params (drop the magic `name:`).** A field's value
+travels with an action only if its `name` equals the param. Hand-writing
+`name: "value"` on every input is easy to forget — the action then silently gets
+nothing. `reactive_input`/`reactive_select` emit the binding for you (the trigger
+stays on the button, so focusing the field doesn't dispatch and collapse edit
+mode):
 
-By default an action re-renders its component in place. **Return** a
-`Phlex::Reactive::Response` to do more (it governs only the actor's HTTP reply —
-cross-tab updates still use `broadcast_*_to(..., exclude: reactive_connection_id)`).
-Returning anything else keeps the default, so existing actions are unaffected.
+```ruby
+action :save, params: { value: :string, status: :string }
 
-The snippets below alias the constant for brevity (`Response.replace(self)` won't
-resolve to `Phlex::Reactive::Response` inside a namespaced component — fully
-qualify it, or add the alias shown):
+def view_template
+  span(id:, **reactive_attrs) do
+    reactive_input(:value, value: @record.name)            # <input name="value" …>
+    reactive_select(:status) do                            # <select name="status">…</select>
+      %w[open closed].each { |s| option(value: s, selected: s == @record.status) { s } }
+    end
+    button(**mix(on(:save), data: { testid: "save" })) { "Save" }
+  end
+end
+```
+
+`reactive_field(:value, **attrs)` returns just the attribute hash if you'd rather
+spread it onto a control yourself. An explicit `name:` still wins (escape hatch).
+
+**Editing an associated record (`accepts_nested_attributes_for`).** `nested_update!`
+maps a declared nested param straight onto `<assoc>_attributes` and carries the
+existing record's id, so `update_only:` matches it in place instead of building a
+second `has_one` (the boilerplate that's easy to get subtly wrong):
 
 ```ruby
-Response = Phlex::Reactive::Response # or qualify each call below
+# Account has_one :address; accepts_nested_attributes_for :address, update_only: true
+action :save, params: { address: { street: :string, city: :string } }
+
+def save(address:)
+  nested_update!(:address, address)   # update!(address_attributes: address.merge(id: @account.address&.id))
+end
+```
+
+`nested_attributes(:address, address)` returns the id-merged hash without
+updating, if you need to combine it with other attributes.
+
+### `reply` — controlling the action's reply
+
+By default an action re-renders its component in place. To do more, **return**
+`reply.<verb>` — a subject-bound builder available in every component. It governs
+only the actor's HTTP reply (cross-tab updates still use
+`broadcast_*_to(..., exclude: reactive_connection_id)`). Returning anything else
+keeps the default, so existing actions are unaffected.
+
+`reply` reads cleanly: the component is the implicit subject (no `self` to
+thread) and there's no constant to qualify (it's a method, so a namespaced
+component needs no alias):
 
+```ruby
 def rename(title:)
-  return Response.replace(self).flash(:error, @todo.errors.full_messages.to_sentence) unless @todo.update(title:)
-  Response.replace(self)
+  return reply.replace.flash(:error, @todo.errors.full_messages.to_sentence) unless @todo.update(title:)
+  reply.replace
 end
 
-def approve   = (@row.approve!; Response.remove(self))          # drop the element
-def publish   = (@article.publish!; Response.redirect(article_url(@article)))  # slug changed → Turbo.visit
-def add(item:) = Response.replace(self).stream(Totals.update(@order))           # multi-stream
+def approve   = (@row.approve!; reply.remove)          # drop the element
+def publish   = (@article.publish!; reply.redirect(article_url(@article)))  # slug changed → Turbo.visit
+def add(item:) = reply.replace.stream(Totals.update(@order))               # multi-stream
+
+# Per-field reactive editing (a "spreadsheet" grid): a debounced save fires
+# while the user is still typing/tabbing. Morph in place so the focused <input>
+# and its in-progress value survive the re-render (issue #28). Note the action is
+# named `update`, yet `reply.morph` is unambiguous — the verb is on `reply`:
+def update(name:) = (@row.update!(name:); reply.morph)
+
+# Re-render a COMPANION element (a heading mirroring the edited name) alongside self:
+def rename(value:) = (@account.update!(name: value); reply.replace.also_update("page_heading", html: @account.name))
+
+# Update ONLY part of the component (issue #30): re-stream just the total cell,
+# NOT the whole row. reply.streams emits exactly your streams plus a tiny
+# token-only refresh — no full-self replace — so a sibling <input> the user is
+# mid-typing in is never torn down. The signed token still rolls forward.
+def update(quantity:, price:) = (@item.update!(quantity:, price:); reply.streams(Totals.update(@item)))
 ```
 
 | Builder | Reply |
 |---|---|
-| `Response.replace(self)` / `.update(self)` | re-render in place (explicit default) |
-| `.flash(level, content, target: …)` | append a flash; `content` is a string or Phlex component (off-request — no Rails `flash`); target defaults to `Phlex::Reactive.flash_target` (`"flash"`) |
-| `Response.remove(self)` | remove the element (backed by `Streamable#to_stream_remove`) |
-| `Response.redirect(url)` | client-side `Turbo.visit` (pass a `*_url`); rides a `reactive:visit` turbo-stream, not an HTTP 3xx |
-| `Response.with(*streams)` / `#stream(*more)` | multi-stream |
-
-`.flash`/`.stream` are additive on a self-replace, so the component's signed
-token always refreshes.
+| `reply.replace` / `reply.update` | re-render in place (default; `replace` is an outerHTML swap, `update` morphs inner HTML) |
+| `reply.morph` / `reply.replace(morph: true)` | re-render in place via Idiomorph (`method="morph"`) — preserves the focused `<input>` + caret; for per-field reactive editing (issue #28) |
+| `.also_update(target, html:)` | also re-render a companion element by DOM id; `html` is a plain string (escaped) or a Phlex component |
+| `.also_replace(component, morph: false)` | also re-render another Streamable component, targeting its own `#id`; `morph: true` morphs it in place |
+| `.flash(level, content, target: …)` | append a flash; `content` is a plain string (escaped) or a Phlex component (off-request — no Rails `flash`); target defaults to `Phlex::Reactive.flash_target` (`"flash"`) |
+| `reply.remove` | remove the element (backed by `Streamable#to_stream_remove`) |
+| `reply.redirect(url)` | client-side `Turbo.visit` (pass a `*_url`); rides a `reactive:visit` turbo-stream, not an HTTP 3xx |
+| `reply.streams(*streams)` | **partial update** — emit exactly these streams (no full-self replace) + a tiny token-only refresh, so live inputs survive; for per-field grid editing (issue #30) |
+| `reply.with(*streams)` / `#stream(*more)` | multi-stream (self re-render still injected for the token) |
+
+`.flash`/`.stream`/`.also_*` are additive on a self-replace, so the component's
+signed token always refreshes. **`reply.streams`** is the exception that proves
+the rule: it deliberately skips the full-self replace (so your hand-built streams
+update only the targets you name) and refreshes the token via a tiny inert
+`reactive:token` stream instead — the token rolls forward without re-rendering
+(and clobbering) the component's live inputs.
+
+> **Under the hood.** `reply.<verb>` returns a `Phlex::Reactive::Response` — the
+> immutable value object the endpoint reads. You can build one directly
+> (`Phlex::Reactive::Response.replace(self)`) and it still works, but `reply` is
+> the preferred surface; treat `Response` as an internal detail.
+> **`html:`/`content` escaping.** A plain string is **HTML-escaped** by Turbo, so
+> **`html:`/`content` escaping.** A plain string is **HTML-escaped** by Turbo, so
+> `html: @account.name` is safe even for user-supplied values. To emit intentional
+> markup, pass a **Phlex component** (`html: Heading.new(name: @record.name)`) —
+> rendered and auto-escaped through the renderer — or an `html_safe` string for
+> raw HTML you control.
 
 ### Configuration (`config/initializers/phlex_reactive.rb`)
 

data/app/controllers/phlex/reactive/actions_controller.rb

@@ -78,6 +78,19 @@ module Phlex
         return [redirect_stream(result.redirect_url)] if result.redirect?
 
         streams = result.streams
+
+        # Partial update (Response.streams / reply.streams, issue #30): the action
+        # re-rendered only PART of the component and opted out of the full-self
+        # replace. Append a tiny token-only stream so the signed token still rolls
+        # forward WITHOUT re-rendering (and clobbering) the live inputs. Skip it
+        # only if the caller already supplied THIS component's token (idempotent) —
+        # the dedupe is scoped to the actor's own target, NOT a global substring,
+        # so a partial reply that legitimately includes another reactive
+        # component's stream (which carries its OWN token) still refreshes ours.
+        if result.refresh_token? && !carries_token_for?(streams, result.token_component)
+          return [*streams, result.token_component.to_stream_token]
+        end
+
         # Guarantee the component's signed identity token is refreshed unless the
         # Response opted out (remove/redirect navigate away — handled above). The
         # client reads the next token from the response body (#extractToken), so
@@ -94,6 +107,17 @@ module Phlex
         streams
       end
 
+      # True when one of `streams` already carries a fresh token TARGETING this
+      # component — i.e. the caller hand-built the actor's own token-bearing
+      # stream, so appending to_stream_token would double it. Scoped to the
+      # component's target id (not a global substring) so a sibling component's
+      # stream, which carries its OWN token for a DIFFERENT target, doesn't fool
+      # us into skipping this component's refresh.
+      def carries_token_for?(streams, component)
+        target = %(target="#{ERB::Util.html_escape(component.id)}")
+        streams.any? { |s| s.include?("data-reactive-token-value") && s.include?(target) }
+      end
+
       # A 200 turbo-stream carrying a namespaced custom action the client turns
       # into Turbo.visit — NOT an HTTP 3xx, which the client hard-bails on
       # (response.redirected). The matching client handler is registered in

data/app/javascript/phlex/reactive/reactive_controller.js

@@ -4,7 +4,8 @@ import { Controller } from "@hotwired/stimulus"
 // replaces the per-feature Stimulus controllers you'd otherwise hand-write
 // for interactive components. A component declares its actions in Ruby (via
 // Phlex::Reactive::Component); this controller binds DOM events to a single
-// HTTP round trip and lets Turbo morph the re-rendered component back in.
+// HTTP round trip and lets Turbo apply the re-rendered component back in
+// (replace by default; method="morph" — Response.morph — preserves focus).
 //
 // Wire format (client -> server), POST <action path>, turbo-stream Accept:
 //   { token: "<signed identity>", act: "<action>", params: {...} }
@@ -31,9 +32,81 @@ export function registerReactiveVisit() {
     if (url) window.Turbo.visit(url, { action: "advance" })
   }
 }
+
+// Custom turbo-stream action: a TOKEN-ONLY refresh (issue #30). A partial
+// update (Response.streams / reply.streams) re-renders only PART of a component
+// — so there's no full-self replace to carry the next signed token. The server
+// instead emits `<turbo-stream action="reactive:token" target="<id>"
+// data-reactive-token-value="<fresh>">`. #perform's #extractToken already reads
+// the token out of the response body for the NEXT queued request; this handler
+// keeps the DOM in sync too, writing the attribute onto the root element so the
+// `tokenValue` fallback stays fresh. It's a pure attribute set — no node is
+// replaced — so a focused <input> + caret survive (the whole point: update a
+// total cell without tearing down the field the user is typing in).
+export function registerReactiveToken() {
+  const actions = window.Turbo?.StreamActions
+  if (!actions || actions["reactive:token"]) return
+  actions["reactive:token"] = function () {
+    const token = this.getAttribute("data-reactive-token-value")
+    const target = this.getAttribute("target")
+    if (!token || !target) return
+    const el = document.getElementById(target)
+    // Stimulus reads the token via the `token` value -> data-reactive-token-value.
+    if (el) el.setAttribute("data-reactive-token-value", token)
+  }
+}
+
+export function registerReactiveActions() {
+  registerReactiveVisit()
+  registerReactiveToken()
+}
+
 if (typeof window !== "undefined") {
-  if (window.Turbo) registerReactiveVisit()
-  else document.addEventListener("turbo:load", registerReactiveVisit, { once: true })
+  if (window.Turbo) registerReactiveActions()
+  else document.addEventListener("turbo:load", registerReactiveActions, { once: true })
+}
+
+// --- Registration guard (issue #26 part 2) -------------------------------
+// In a `lazyLoadControllersFrom("controllers", application)` app, only
+// controllers under app/javascript/controllers/ are registered. This module
+// lives outside that dir, so importing it isn't enough — `data-controller=
+// "reactive"` does NOTHING until the host runs application.register("reactive",
+// ...). The failure is silent: components render, but no action ever fires.
+//
+// We can't warn from connect() in that case (connect never runs). Instead, once
+// the page is ready, if reactive elements exist but no controller has connected,
+// the controller wasn't registered — so we warn, pointing at the fix.
+let reactiveConnected = false
+
+export function checkReactiveRegistration() {
+  if (reactiveConnected) return
+  if (typeof document === "undefined") return
+  const els = document.querySelectorAll('[data-controller~="reactive"]')
+  if (!els || els.length === 0) return
+  console.warn(
+    "[phlex-reactive] found " + els.length + ' element(s) with data-controller="reactive" ' +
+      "but the reactive controller never connected. It is loaded but not registered — " +
+      'add `application.register("reactive", ReactiveController)` (importmap) or import it ' +
+      "into app/javascript/controllers/ for lazyLoadControllersFrom apps. See the README."
+  )
+}
+
+// Test seams (no-ops in production usage).
+export function __resetReactiveRegistrationForTest() {
+  reactiveConnected = false
+}
+export function __markReactiveConnectedForTest() {
+  reactiveConnected = true
+}
+
+if (typeof window !== "undefined" && typeof document !== "undefined") {
+  // Defer past initial controller connection (a microtask/tick after ready).
+  const scheduleCheck = () => setTimeout(checkReactiveRegistration, 0)
+  if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", scheduleCheck, { once: true })
+  } else {
+    scheduleCheck()
+  }
 }
 
 // Register this controller eagerly (not lazily) so a click immediately after
@@ -47,6 +120,12 @@ export default class extends Controller {
   #tokenCache // freshest token, threaded synchronously across queued requests
   #debounceTimers = new Map() // trigger element -> { timer, flush } pending dispatch
 
+  // Mark that a reactive controller actually connected, so the registration
+  // guard above knows the controller was registered (issue #26 part 2).
+  connect() {
+    reactiveConnected = true
+  }
+
   // Tear down any pending debounce timers when the controller leaves the DOM
   // (Turbo morph/navigation removes the element). Otherwise a timer that hasn't
   // fired yet would later call #enqueue on a disconnected controller — a round
@@ -173,8 +252,10 @@ export default class extends Controller {
       // Capture the new token from the response synchronously, so the next
       // queued request uses it without waiting for the async DOM morph.
       this.#currentToken = this.#extractToken(html) ?? this.#currentToken
-      // Turbo applies the <turbo-stream> ops (replace/morph by id), preserving
-      // focus/scroll/listeners on unchanged nodes.
+      // Turbo applies the <turbo-stream> ops by id. A plain replace is an
+      // outerHTML swap (focus on the replaced subtree is lost); a method="morph"
+      // replace (Response.morph) or an update morphs in place, preserving the
+      // focused input + caret on unchanged nodes — see issue #28.
       window.Turbo.renderStreamMessage(html)
     } catch (error) {
       console.error("[phlex-reactive] action error", error)

data/lib/phlex/reactive/component.rb

@@ -5,8 +5,10 @@ module Phlex
     # Component turns a self-contained Phlex component into a Livewire-style
     # reactive unit: declare actions in Ruby, and the generic `reactive`
     # Stimulus controller wires clicks/inputs to an HTTP round trip that
-    # re-renders the component and morphs it back into the DOM. No per-feature
-    # Stimulus controllers, no hand-picked Turbo targets.
+    # re-renders the component and applies it back into the DOM (a plain replace
+    # by default; return Response.morph(self) to morph in place and keep the
+    # focused input — issue #28). No per-feature Stimulus controllers, no
+    # hand-picked Turbo targets.
     #
     # Include alongside Phlex::Reactive::Streamable (which provides #id and the
     # re-render machinery).
@@ -167,6 +169,22 @@ module Phlex
         Phlex::Reactive.current_connection_id
       end
 
+      # Subject-bound reply builder — the preferred way to control an action's
+      # reply. `reply.replace.flash(:error, msg)` reads cleaner than
+      # `Phlex::Reactive::Response.replace(self).flash(:error, msg)`: the
+      # component is the implicit subject (no `self` to thread) and there's no
+      # constant to qualify (reply is a method, so a namespaced component needs
+      # no `Response = …` alias). It returns the same immutable Response the
+      # endpoint reads, so chaining and the legacy return-value contract are
+      # unchanged. See Phlex::Reactive::Reply.
+      #
+      #   def archive       = reply.remove
+      #   def go_home       = reply.redirect("/todos")
+      #   def update(name:) = (@account.update!(name:); reply.morph)
+      def reply
+        Phlex::Reactive::Reply.new(self)
+      end
+
       # Root-element attributes: marks the element reactive and carries the
       # signed identity token. Spread onto the root:
       #   div(id:, **reactive_attrs) { ... }
@@ -206,8 +224,72 @@ module Phlex
         attrs
       end
 
+      # Bind a form control's `name` to an action param so its value travels with
+      # the action — instead of hand-writing the magic `name: "value"` on every
+      # input and silently getting no params when you forget it (issue #23).
+      # Returns a Phlex attributes hash to spread onto any control:
+      #   input(**reactive_field(:value, value: @record.name))
+      #   select(**reactive_field(:status)) { ... }
+      # Extra attrs merge over the binding; an explicit name: still wins (escape
+      # hatch). The trigger (on(:save)) stays on the button, not the field — so
+      # focusing the input doesn't dispatch and collapse edit mode.
+      def reactive_field(param, **attrs)
+        {name: param.to_s, **attrs}
+      end
+
+      # Render an <input> already bound to an action param (issue #23). Sugar for
+      # input(**reactive_field(param, **attrs)); the value/type/etc. pass through.
+      #   reactive_input(:value, value: @record.name, type: "text")
+      def reactive_input(param, **attrs)
+        input(**reactive_field(param, **attrs))
+      end
+
+      # Render a <select> bound to an action param (issue #23). The options block
+      # is the element's content, so the awkward FormBuilder positional split
+      # (where name: lands after the options/html-options args) goes away:
+      #   reactive_select(:status) { @statuses.each { |s| option(value: s, selected: s == @record.status) { s } } }
+      def reactive_select(param, **attrs, &block)
+        select(**reactive_field(param, **attrs), &block)
+      end
+
+      # Map a declared nested param onto Rails' <assoc>_attributes, carrying the
+      # existing associated record's id so accepts_nested_attributes_for matches
+      # it IN PLACE instead of building a second one (issue #24). Returns the
+      # update hash; pass it to update!:
+      #   def save(address:) = nested_update!(:address, address)
+      # The id is only added when the association already exists, so the first
+      # save (no associated record yet) creates one cleanly. The given attrs are
+      # not mutated.
+      def nested_attributes(association, attrs)
+        merged = attrs.dup
+        existing = reactive_record_for_nested.public_send(association)
+        merged[:id] = existing.id if existing
+
+        {"#{association}_attributes": merged}
+      end
+
+      # Map a nested param onto <assoc>_attributes (with id preservation) AND
+      # apply it to the component's record in one call (issue #24). Extra keyword
+      # attributes update alongside the association.
+      #   def save(address:, name:) = nested_update!(:address, address, name:)
+      def nested_update!(association, attrs, **extra)
+        reactive_record_for_nested.update!(**nested_attributes(association, attrs), **extra)
+      end
+
       private
 
+      # The component's record, for the nested-attributes helpers. Requires a
+      # declared reactive_record (the nested helper only makes sense for a
+      # record-backed component).
+      def reactive_record_for_nested
+        key = self.class.reactive_record_key
+        unless key
+          raise Error, "#{self.class} must declare `reactive_record` to use nested_update!/nested_attributes"
+        end
+
+        instance_variable_get(:"@#{key}")
+      end
+
       # Signed identity payload: the class name plus whichever identity pieces
       # the component declares — a record GlobalID (`gid`), signed state (`s`),
       # or both. Keeping them in ONE MessageVerifier payload makes the state

data/lib/phlex/reactive/engine.rb

@@ -40,6 +40,15 @@ module Phlex
           )
         end
       end
+
+      # Boot-time guard (issue #26): warn if the action path doesn't resolve to
+      # the gem controller. Runs after_initialize so the host's full route set
+      # (including a bottom-of-file catch-all that would shadow our appended
+      # route) is drawn. Turns the opaque "every reactive POST 404s" failure into
+      # a one-line log pointing at the cause. No-op when the route is fine.
+      config.after_initialize do
+        Phlex::Reactive.warn_unless_action_route_mounted!
+      end
     end
   end
 end

data/lib/phlex/reactive/reply.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Phlex
+  module Reactive
+    # A component-bound facade over Response — the surface an action body uses to
+    # control its reply. Component#reply returns one, so an action writes
+    #
+    #   reply.replace.flash(:error, msg)
+    #
+    # instead of
+    #
+    #   Phlex::Reactive::Response.replace(self).flash(:error, msg)
+    #
+    # Two warts disappear: there is no constant to qualify (reply is a method,
+    # resolved on the component — so a namespaced component needs no
+    # `Response = …` alias) and no `self` to thread (the component is bound).
+    #
+    # Reply is NOT a Response and does NOT subclass one: each verb forwards to
+    # the Response class method, supplying the bound component as the subject, and
+    # returns the real, frozen Response value the endpoint already honors. So
+    # immutability, chaining (.flash/.stream/.also_update/.also_replace), and
+    # render_self? are inherited untouched — and there is no "verb after a chained
+    # Response" asymmetry, because the chain is plain Response all the way down.
+    #
+    # Response remains the public value object (it's what the endpoint reads); it
+    # is simply an internal detail you rarely name directly now.
+    class Reply
+      def initialize(component)
+        @component = component
+      end
+
+      # Self-targeting builders — the bound component is supplied implicitly.
+
+      # Re-render in place. `morph: true` morphs the subtree (preserves the
+      # focused input + caret) instead of an outerHTML swap — see #morph.
+      def replace(morph: false)
+        Response.replace(@component, morph:)
+      end
+
+      # Re-render in place via Idiomorph (method="morph") — keeps focus + caret.
+      def morph
+        Response.morph(@component)
+      end
+
+      # Morph only inner HTML (preserves the root element + its token attr).
+      def update
+        Response.update(@component)
+      end
+
+      # Remove the component's element from the DOM (render_self false).
+      def remove
+        Response.remove(@component)
+      end
+
+      # Subject-free builders — pass straight through so they read naturally.
+
+      # Client-side full navigation (Turbo.visit). Pass a *_url.
+      def redirect(url)
+        Response.redirect(url)
+      end
+
+      # Escape hatch / multi-stream root: zero or more raw turbo-stream strings.
+      def with(*strings)
+        Response.with(*strings)
+      end
+
+      # Self-targeting again: emit exactly these streams with a TOKEN-ONLY refresh
+      # (issue #30) — partial/per-field update, NO full-self replace, so the
+      # component's live inputs survive. The bound component supplies the token.
+      def streams(*strings)
+        Response.streams(@component, *strings)
+      end
+    end
+  end
+end

data/lib/phlex/reactive/response.rb

@@ -12,15 +12,28 @@ module Phlex
     #
     #   Response.replace(self)                          # re-render in place (the default, explicit)
     #   Response.replace(self).flash(:error, msg)       # surface a validation error
+    #   Response.replace(self).also_update("heading", html: @record.name)  # + a companion element
     #   Response.remove(self)                           # drop the element (e.g. moderation queue)
     #   Response.redirect(article_url(@article))        # slug changed -> Turbo.visit the new URL
     #   Response.replace(self).stream(Totals.update(@order))  # multi-stream
     class Response
-      attr_reader :streams, :redirect_url
+      attr_reader :streams, :redirect_url, :token_component
 
       class << self
         # Re-render the component in place (explicit form of today's default).
-        def replace(component) = new(streams: [component.to_stream_replace])
+        # `morph: true` morphs the subtree (preserves the focused input + caret)
+        # instead of an outerHTML swap — see .morph (issue #28).
+        def replace(component, morph: false)
+          new(streams: [morph ? component.to_stream_morph : component.to_stream_replace])
+        end
+
+        # Re-render the component in place via Idiomorph (issue #28). Emits
+        # `<turbo-stream action="replace" method="morph">`, so Turbo 8 morphs the
+        # subtree — the focused <input> + caret survive the save. Use this for
+        # per-field reactive editing (a "spreadsheet" grid where a debounced save
+        # fires while the user is still typing/tabbing). The morphed root still
+        # carries the fresh signed token, so the next action verifies.
+        def morph(component) = new(streams: [component.to_stream_morph])
 
         # Morph only inner HTML (preserves the root element + its token attr).
         def update(component) = new(streams: [component.to_stream_update])
@@ -38,14 +51,49 @@ module Phlex
         # Escape hatch / multi-stream root: zero or more raw turbo-stream strings.
         def with(*strings) = new(streams: strings.flatten)
 
+        # Partial / per-field update with a TOKEN-ONLY refresh (issue #30). Emits
+        # EXACTLY the given streams — no forced full-self replace — but binds
+        # `component` so the endpoint appends its tiny `to_stream_token` stream.
+        # So the signed token rolls forward (the next action verifies) while the
+        # component's own live inputs are never torn down: ideal for a
+        # spreadsheet-like grid where a debounced save re-streams only a total
+        # cell and the user is still typing in a sibling field.
+        #
+        #   Response.streams(self, Totals.update(@invoice))   # update only the totals
+        #
+        # render_self is false (we do NOT inject the full replace); the token is
+        # refreshed by the bound component's token stream instead.
+        def streams(component, *strings)
+          new(streams: strings.flatten, render_self: false, token_component: component)
+        end
+
         # Build a flash turbo-stream that appends `content` into a host-app
         # container. `content` is a Phlex component instance (rendered through
         # the configured renderer so t()/url_for work) or a ready HTML string —
         # supplied by the caller because the render context is off-request
         # (there is no Rails `flash`).
         def flash_stream(_level, content, target:)
-          html = content.is_a?(::Phlex::SGML) ? Phlex::Reactive.render(content) : content.to_s
-          Phlex::Reactive.flash_builder.append(target, html: html)
+          Phlex::Reactive.flash_builder.append(target, html: render_html(content))
+        end
+
+        # Build a turbo-stream that updates an arbitrary target id with `content`
+        # (a Phlex component instance or an HTML string). Used by #also_update to
+        # re-render a companion element that isn't itself a Streamable component.
+        def update_stream(target, content)
+          Phlex::Reactive.flash_builder.update(target, html: render_html(content))
+        end
+
+        # Resolve `content` to the HTML for a turbo-stream's `html:`. Two forms,
+        # both SAFE against injection by default:
+        #   * a Phlex component instance — rendered through the configured
+        #     renderer, which auto-escapes interpolated values.
+        #   * any other value — coerced with to_s and handed to Turbo's
+        #     TagBuilder, which HTML-ESCAPES a plain String. So a model value
+        #     (`html: @record.name`) cannot inject markup. To emit intentional
+        #     raw HTML, pass an `html_safe` String (Turbo leaves those verbatim)
+        #     or a Phlex component. Same contract as the pre-existing flash_stream.
+        def render_html(content)
+          content.is_a?(::Phlex::SGML) ? Phlex::Reactive.render(content) : content.to_s
         end
       end
 
@@ -53,10 +101,16 @@ module Phlex
       # GUARANTEES the component's own replace is present so its
       # data-reactive-token-value refreshes (the client extracts the next token
       # from the response HTML). remove/redirect set it false (nothing stays).
-      def initialize(streams: [], redirect_url: nil, render_self: true)
+      #
+      # token_component: set by .streams (issue #30) — a partial update that opts
+      # OUT of the full-self replace but still needs the token refreshed. The
+      # endpoint appends this component's tiny to_stream_token instead, so the
+      # token rolls forward without re-rendering (and clobbering) the children.
+      def initialize(streams: [], redirect_url: nil, render_self: true, token_component: nil)
         @streams = streams.freeze
         @redirect_url = redirect_url
         @render_self = render_self
+        @token_component = token_component
         freeze
       end
 
@@ -66,7 +120,8 @@ module Phlex
         self.class.new(
           streams: @streams + more.flatten,
           redirect_url: @redirect_url,
-          render_self: @render_self
+          render_self: @render_self,
+          token_component: @token_component
         )
       end
 
@@ -76,8 +131,36 @@ module Phlex
         stream(self.class.flash_stream(level, content, target:))
       end
 
+      # Also re-render a COMPANION element alongside self — a page heading, a
+      # summary card, a badge that recomputes from the saved value (issue #25).
+      # `target` is the sibling element's DOM id. `html` is either:
+      #   * a plain String — HTML-ESCAPED by Turbo, so a model value is safe:
+      #       Response.replace(self).also_update("page_heading", html: @record.name)
+      #   * a Phlex component — rendered + auto-escaped through the renderer (use
+      #     this when the companion has its own markup), or an `html_safe` String
+      #     for intentional raw HTML.
+      # Returns a NEW Response (immutable). The common "re-render self + N
+      # siblings" case no longer needs raw turbo_stream_builder.
+      def also_update(target, html:)
+        stream(self.class.update_stream(target, html))
+      end
+
+      # Like #also_update, but renders ANOTHER Streamable component and replaces
+      # it by its own #id — for a companion that is itself a component.
+      #   Response.replace(self).also_replace(SummaryCard.new(order: @order))
+      # `morph: true` morphs the companion in place (issue #28) — use it when the
+      # companion also holds focusable inputs that must survive the re-render.
+      def also_replace(component, morph: false)
+        stream(morph ? component.to_stream_morph : component.to_stream_replace)
+      end
+
       def redirect? = !@redirect_url.nil?
       def render_self? = @render_self
+
+      # True when a partial update (.streams) opted out of the full-self replace
+      # but still needs the token rolled forward — the endpoint appends the bound
+      # component's tiny token-only stream (issue #30).
+      def refresh_token? = !@token_component.nil?
     end
   end
 end

data/lib/phlex/reactive/streamable.rb

@@ -64,9 +64,13 @@ module Phlex
           renderer.render(component, layout: false)
         end
 
-        def replace(model = nil, **options)
+        # `morph: true` emits `<turbo-stream action="replace" method="morph">` so
+        # Turbo 8's bundled Idiomorph morphs the subtree in place — preserving a
+        # focused <input> + caret — instead of an outerHTML swap (issue #28).
+        # Default (morph: false) is the unchanged plain replace.
+        def replace(model = nil, morph: false, **options)
           component = build(model, options)
-          turbo_stream_builder.replace(component.id, html: render_component(component))
+          turbo_stream_builder.replace(component.id, html: render_component(component), **morph_method(morph))
         end
 
         def update(model = nil, **options)
@@ -103,11 +107,15 @@ module Phlex
         # connection id — pass it to suppress the actor's own echo (the actor
         # already got the action's HTTP response). With Action Cable these are
         # ignored; with pgbus they reach the dispatcher. See docs/broadcasting.
-        def broadcast_replace_to(*streamables, model: nil, exclude: nil, visible_to: nil, **options)
+        # `morph: true` makes the live cross-tab update morph in place (issue #28),
+        # so a peer tab keeps its focus/caret on the morphed row. The broadcast
+        # path takes EXTRA <turbo-stream> attributes via `attributes:` (not the
+        # TagBuilder's `method:` kwarg), so the morph flag rides there.
+        def broadcast_replace_to(*streamables, model: nil, exclude: nil, visible_to: nil, morph: false, **options)
           component = build(model, options)
           ::Turbo::StreamsChannel.broadcast_replace_to(
             *streamables, target: component.id, html: render_component(component),
-            **broadcast_transport_opts(exclude:, visible_to:)
+            **morph_attributes(morph), **broadcast_transport_opts(exclude:, visible_to:)
           )
         end
 
@@ -149,6 +157,20 @@ module Phlex
           new(**(model ? component_args(model, options) : options))
         end
 
+        # The TagBuilder (the .replace class builder + to_stream_morph) takes
+        # `method: :morph` to emit the `method="morph"` attribute. Pass it ONLY
+        # when morphing, so the default call produces today's plain replace.
+        def morph_method(morph)
+          morph ? {method: :morph} : {}
+        end
+
+        # The BROADCAST path renders extra <turbo-stream> attributes through
+        # `attributes:` (it has no `method:` kwarg — that would fall into the
+        # render args and be dropped). Same wire result: method="morph".
+        def morph_attributes(morph)
+          morph ? {attributes: {method: "morph"}} : {}
+        end
+
         # Only include transport opts that were actually given, so on Action
         # Cable (which doesn't accept them) the common no-opts call is unchanged.
         def broadcast_transport_opts(exclude:, visible_to:)
@@ -184,10 +206,38 @@ module Phlex
         self.class.turbo_stream_builder.replace(id, html: self.class.render_component(self))
       end
 
+      # Render THIS instance as a MORPHING replace (issue #28):
+      # `<turbo-stream action="replace" method="morph">`. Turbo 8's bundled
+      # Idiomorph morphs the subtree in place — preserving the focused <input> +
+      # caret across the re-render — while still carrying the root's fresh
+      # data-reactive-token-value (so the signed token refreshes). Used by
+      # Response.morph / Response.replace(self, morph: true).
+      def to_stream_morph
+        self.class.turbo_stream_builder.replace(id, html: self.class.render_component(self), method: :morph)
+      end
+
       def to_stream_update
         self.class.turbo_stream_builder.update(id, html: self.class.render_component(self))
       end
 
+      # Render a TOKEN-ONLY refresh stream (issue #30): a tiny
+      # `<turbo-stream action="reactive:token">` carrying the component's fresh
+      # signed token, with NO rendered body. It lets an action update only PART
+      # of a component (its own hand-built streams) while still rolling the
+      # signed identity token forward — the client reads the next token from this
+      # attribute (#extractToken) and an inert client action writes it onto the
+      # root (a pure attribute set, so a focused <input> + caret survive). Unlike
+      # to_stream_replace, it does NOT re-render the children, so a live input
+      # the user is typing into is never torn down. Used by Response.streams.
+      #
+      # The component carries its token via Component#reactive_token; a Streamable
+      # that isn't a Component (no token) simply has nothing to refresh — guarded
+      # by respond_to? so the primitive stays usable on a bare Streamable.
+      def to_stream_token
+        token = respond_to?(:reactive_token) ? reactive_token : nil
+        %(<turbo-stream action="reactive:token" target="#{ERB::Util.html_escape(id)}" data-reactive-token-value="#{ERB::Util.html_escape(token)}"></turbo-stream>)
+      end
+
       # Render THIS instance as a remove stream. The component already knows its
       # own #id, so no record/class reconstruction is needed (works for record-
       # and state-backed components alike). Used by Response.remove.

data/lib/phlex/reactive/version.rb

@@ -2,6 +2,6 @@
 
 module Phlex
   module Reactive
-    VERSION = "0.2.8"
+    VERSION = "0.3.0"
   end
 end

data/lib/phlex/reactive.rb

@@ -133,8 +133,62 @@ module Phlex
         Thread.current[:phlex_reactive_connection_id] = previous
       end
 
+      # The controller a correctly-mounted action path resolves to. Used by the
+      # route guard below.
+      ACTIONS_CONTROLLER = "phlex/reactive/actions"
+
+      # True when a POST to `path` resolves to the gem's ActionsController. A host
+      # catch-all route (match "*path", ...) appended above the engine's route
+      # SHADOWS it, so every reactive POST 404s and none of the controller runs —
+      # the opaque "is the endpoint even mounted?" failure (issue #26). A false
+      # here is the signal. Returns false (not raise) when nothing matches.
+      def action_route_ok?(path = action_path)
+        return false unless defined?(::Rails) && ::Rails.application
+
+        # At after_initialize (when the boot guard runs) the host's routes may not
+        # be drawn yet, so recognize_path would see an incomplete set and report a
+        # false shadow. Force-load routes first (idempotent — no-op if already
+        # loaded), so the check is correct whether it runs at boot or at runtime.
+        ensure_routes_loaded
+        recognized = ::Rails.application.routes.recognize_path(path, method: :post)
+        recognized[:controller] == ACTIONS_CONTROLLER
+      rescue ActionController::RoutingError, ActiveRecord::RecordNotFound
+        false
+      end
+
+      # Log a clear warning (once, at boot) when the action path doesn't resolve
+      # to the gem controller — pointing at the catch-all shadow rather than
+      # leaving an adopter to guess. Called from the engine's after_initialize.
+      def warn_unless_action_route_mounted!(path: action_path, logger: default_logger)
+        return if action_route_ok?(path)
+        return unless logger
+
+        logger.warn(
+          "[phlex-reactive] POST #{path} does not resolve to #{ACTIONS_CONTROLLER}. " \
+          "A host catch-all route (e.g. match \"*path\", ...) likely shadows it, so reactive " \
+          "actions will 404. Exempt #{path.sub(%r{\A/}, "")} from the catch-all, or set " \
+          "Phlex::Reactive.action_path to an unshadowed path. See the README integration section."
+        )
+      end
+
       private
 
+      # Materialize the route set if it hasn't been drawn yet (the engine appends
+      # POST /reactive/actions when routes are drawn, which may be after the boot
+      # guard's after_initialize). Idempotent; tolerant of older Rails.
+      def ensure_routes_loaded
+        reloader = ::Rails.application.routes_reloader
+        if reloader.respond_to?(:execute_unless_loaded)
+          reloader.execute_unless_loaded
+        elsif ::Rails.application.respond_to?(:reload_routes_unless_loaded)
+          ::Rails.application.reload_routes_unless_loaded
+        end
+      end
+
+      def default_logger
+        ::Rails.logger if defined?(::Rails) && ::Rails.respond_to?(:logger)
+      end
+
       def default_verifier
         unless defined?(::Rails) && ::Rails.application
           raise Error, "Phlex::Reactive.verifier is unset and Rails.application is unavailable; " \

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: phlex-reactive
 version: !ruby/object:Gem::Version
-  version: 0.2.8
+  version: 0.3.0
 platform: ruby
 authors:
 - Mikael Henriksson
@@ -129,6 +129,7 @@ files:
 - lib/phlex/reactive.rb
 - lib/phlex/reactive/component.rb
 - lib/phlex/reactive/engine.rb
+- lib/phlex/reactive/reply.rb
 - lib/phlex/reactive/response.rb
 - lib/phlex/reactive/streamable.rb
 - lib/phlex/reactive/version.rb