live_cable 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9eab70af0621e69a52c7eaccce2d76a400a8627223c6aa91525230d262179782
-  data.tar.gz: 1a6ca70d53e728fc4893607bc5de7ab12094bbdefb06d52cd2a83afefd653ac5
+  metadata.gz: e057aa97b7e7358e132b96ab748c410e60b4d60012ae12bbc8f1007e7e49465a
+  data.tar.gz: aa0da7bec89699efe1eb46ceae11a58fdd686db5f6e39d6d45b36e3304f52d57
 SHA512:
-  metadata.gz: b43cf0bd548271aeae7534a26d1d950266078f3f571165fb99d5daec8021d1c8af16b29f2b71866aa6030594b5e829ecc59bcf4186b4209666472f81d3b7c9bf
-  data.tar.gz: 3d7753820b0ff173ae72a210eb4ecfbf77704e1897a2ebf570c085e7bad6ec1a7531bb7138beb64cf0fadd2af39ee77cf6be0f0e493961d770cd11182e2d3a43
+  metadata.gz: e6327de430dba2dc315a2eb220f12f5ae4934630f0e18533aba25de624f963d68a19155eb9857282655978f363ec524ee850f57080aa738e0f308cda6946e7a9
+  data.tar.gz: 630e1deca5298f6c40b80b626b89a71c7848ddba520b4e635dfe3f7db105f6dd5469c0296789ad116d3718e518be33ad1f8d9ed11d8b5a94b7e66c6a591a34fb

data/CHANGELOG.md

@@ -6,6 +6,573 @@ The Ruby gem (`live_cable`) and the npm package (`@isometriks/live_cable`) are
 released together and share a single version number. Entries below note which
 side of the pair a change affects when it isn't both.
 
+## Unreleased
+
+### Upgrading from 0.4
+
+The gem and the npm package work with each other at 0.4 in either
+direction, but upgrade both to get every fix. A few fixes change behaviour an
+application could notice:
+
+- A template that reads a local assigned inside an earlier block, with no
+  component method or view helper of that name, now raises `NoMethodError`
+  instead of rendering nothing.
+- A component method named like a Kernel method (`open`, `test`, `select`, …)
+  now wins over Kernel in its template; call it on `Kernel`, as in
+  `Kernel.rand`, to reach Kernel's. Don't name a component method `format`:
+  ActionView reads it as the template's format.
+- A tag that reassigns a local set by an earlier top-level `<% %>` tag now
+  re-runs on every update, so later tags see the right value. Keep expensive
+  work out of such tags.
+- A loading state now ends only on the component's own reply. A message held
+  while the socket was down stays loading until it is answered.
+- A focused text field keeps what the user typed through renders it didn't
+  ask for. To clear a field after a submit, bind it to a reactive variable and
+  reset that in the action.
+- `live_mount(..., raise_errors: false)` no longer raises when the first
+  render fails; assert on `broadcasts(:_error)` instead.
+- A template now gets the plain Array, Hash or model inside a reactive
+  variable, so Rails helpers and `case` see the real value. A template that
+  changes a reactive value in place no longer marks it dirty; change it in the
+  component. `component.x` in a template still returns the tracked wrapper.
+- In component code, values reached through `fetch`, `dig`, `detect`,
+  `Hash#each` and `each_value` are tracked wrappers now, so writes through
+  them mark the variable dirty. Use `to_a`, `to_h` or `__getobj__` where code
+  needs the real Array or Hash.
+- A model held in a reactive variable is watched on the record itself. A
+  write through any reference to it, a `reload`, or a validation that
+  normalises an attribute now marks the variable dirty and re-renders.
+- An error raised by an initial-value lambda goes through normal error
+  handling instead of storing `nil`: a root's subscribe answers with an
+  `_error`, and a failing child replaces its parent with the error box. An
+  initial value that isn't a proc raises `ArgumentError` when the class loads.
+- Defaults are signed in their `as_json` form, and a prerendered root
+  renders with that form too, so a Symbol default is a String on page load as
+  well as after subscribe. In development and test, a default that changes on
+  the way logs a warning.
+- A child its parent renders now runs its render callbacks on each of those
+  renders. On page load they run before its connect callbacks, without
+  connection identifiers such as `current_user`.
+- When a component re-renders, parts that read a non-reactive `shared`
+  variable render again too.
+- A checkbox with `live-reactive` sends `true` or `false`, and a `<select
+  multiple>` sends an Array of values, instead of the element's `value`.
+- A render that changes nothing on the page is no longer sent. An action
+  whose changes no part of the template shows is answered with an `_ack`, so
+  a test expecting a `_refresh` after one should expect `broadcasts(:_ack)`.
+- Renders over the socket now share one controller per connection. A
+  `helper_method` on `ApplicationController` that memoizes into an instance
+  variable keeps its value for the connection rather than for one render.
+  These renders have no session or params, so this only matters for a value
+  that changes over time.
+
+### Fixed
+
+- **A template local could render blank or stale.** Dependency
+  tracking parsed each part of a `.live.erb` template on its own and ignored
+  Ruby's block scopes. A local assigned inside a block leaked into later
+  parts, so a later `<%= css %>` rendered blank instead of calling the
+  component's `css`; a top-level local updated inside a block, as in
+  `<% counts.each { |c| total += c } %>`, kept its earlier value in later
+  parts; and a local reassigned in an `if` that didn't run became `nil`.
+  Block parameters also counted as dependencies, so a part re-rendered
+  whenever a reactive variable of the same name changed. Each part is now
+  parsed with the earlier parts' locals in scope, so names resolve as they
+  would in a plain ERB template. Two templates behave differently: one that
+  reads a block's local after the block, with no component method or view
+  helper of that name, now raises `NoMethodError` ("undefined method 'last'"
+  for a local named `last`) instead of rendering nothing, much as plain ERB
+  raises `NameError`; and a local reassigned in a branch that doesn't run
+  keeps its value instead of becoming `nil` (gem).
+- **A block passed to a view helper that renders a partial landed above the
+  partial.** A helper such as `def card(&) = render(layout: 'shared/card', &)`,
+  used from a `.live.erb` template as `<%= card do %>`, wrote the block's
+  content before the card and left stray escaped markup where the card
+  yields. 0.4.0 fixed this for `render` called by the template itself; a
+  block the template passes to any view helper is now handled the same way.
+  Helpers that capture their block, such as `form_with` and `content_tag`,
+  are unaffected (gem).
+- **The error for a `.live.erb` template rendered as a partial didn't say
+  which template.** The message began "A .live.erb template", and the
+  backtrace points into LiveCable rather than at the template. It now opens
+  with the template's path, such as
+  `app/views/shared/_live_card.html.live.erb` (gem).
+- **Template names that Kernel or Object also define, like `open`, `select`
+  or `test`, ran the Kernel method instead of the component's or the view
+  helper's.** A `.live.erb` template resolves bare names to the component and
+  then the view context, but names the renderer already had from Kernel or
+  Object never got that far. A component with `reactive :open` and
+  `<% if open %>` raised an `ArgumentError` on the page and on mount, the
+  `select` form helper raised a `TypeError`, and `j` printed to standard output
+  instead of escaping. These names now go to the component or the view context
+  whenever either defines them. When neither does they still call the Kernel
+  method, so `format`, `rand` and `lambda` work as before. A component method
+  with such a name now wins in its template; call it on `Kernel`, as in
+  `Kernel.rand`, to reach the Kernel method (gem).
+- **A child hidden after its parent re-rendered something else was never
+  destroyed.** A parent only remembered the inline children of the parts its
+  last render had run, so after a render that skipped a child's part it no
+  longer knew it had that child. That happened on any change the part doesn't
+  depend on, and whenever the parent was re-rendered inline by its own parent
+  with nothing changed. Hiding the child later, a render error in the parent,
+  or the parent's own destroy then left the child subscribed, with its
+  `stream_from` streams running, until the socket closed. A compound component
+  that switched to a variant with fewer parts leaked the children of the parts
+  that went away in the same way. A parent now keeps the children of the parts
+  a render skipped, and destroys any its new template no longer renders (gem).
+- **A `stream_from` callback could still run after `stop_stream`.**
+  ActionCable runs each broadcast as its own job on its worker pool, and
+  stopping a stream can't take back a job already queued. A chat that
+  switched rooms with `stop_stream` and a new `stream_from` could still run a
+  callback for the old room after the switch. With a reactive array, the old
+  room's message was appended to the new room's list and stayed there. A
+  callback now checks, under the connection lock, that its stream is still
+  running, so once `stop_stream` returns none of its callbacks run. Stopping a
+  stream and starting it again under the same name still delivers what was
+  already queued. `stop_stream` also kept every name it had stopped, a list
+  that grew with each switch. The new `stop_stream_from(name)` stops one
+  stream and leaves the component's others running (gem).
+- **Another user's broadcast re-enabled a `live-disable-with` button whose own
+  message was still in flight.** The client ended a component's loading state
+  on every `_refresh`, including renders it never asked for - a `stream_from`
+  callback's, or one caused by another component's action - and a parent's
+  re-render rebuilt a nested component's pending button, so someone else's
+  chat message could re-enable your Send button and invite a double submit.
+  A nested component re-rendered only inside its parent's render got no reply
+  at all, and stalled after 30 seconds. The server now
+  marks the render that answers a message with `_reply`, or sends an `_ack`
+  when the component sent no render of its own, and the client ends a loading
+  state only on a reply, an `_ack` or an `_error`; pending elements keep their
+  state through other renders and catch up when it comes. Frames captured by
+  `LiveCable::Testing` carry the new `_reply` and `_subscribed` keys. A message
+  held while the socket was down now stays loading until its own reply, and
+  one lost with the socket stops when it closes or the component
+  re-subscribes. Either side works with the other at 0.4.0 (gem + npm).
+- **Typing in a focused field was undone by a render the user didn't ask
+  for.** Every refresh is morphed in from HTML rebuilt from the component's
+  stored parts, which set each field back to the last value the server
+  rendered. In a chat with a debounced `live-reactive` draft, each incoming
+  `stream_from` message, or a render caused by another component, dropped
+  what had been typed since the last send, and the debounced send that
+  followed sent what was left. A focused text field or textarea now keeps
+  what has been typed unless the server changed its value. A re-render that
+  answers the field's own form or action still applies the server's value,
+  so an input cleared after a submit is still cleared. Unfocused fields,
+  checkboxes, radios and selects behave as before. A focused field that
+  isn't bound to a reactive variable is no longer cleared by a render it
+  didn't ask for; to clear it after a submit, bind it and reset the variable
+  in the action (npm).
+- **A Turbo Drive visit removed the inline children of a component that
+  stayed on the page.** Before Turbo renders a new page, LiveCable closes the
+  subscription of every component that isn't on it. The HTTP prerender gives
+  a live id only to the root component, so a child rendered inline by its
+  parent looked like it was leaving, even when the parent (a layout
+  component, say) was staying. The child was torn down on the server, and the
+  parent had nothing to rebuild it from, so it disappeared from the page. A
+  component that stays on the page now also keeps the children it renders
+  with `.live.erb` templates, and theirs, with their subscriptions and live
+  state (npm).
+- **`live_mount(..., raise_errors: false)` still raised when the first render
+  or a `connect` callback failed.**
+  `live_mount` ran `connect` and the first render with no rescue, so an error
+  in either still raised, while production sends it through the connection's
+  error handling and transmits an `_error`. `live_mount` now handles those
+  errors the same way `LiveChannel#subscribed` does. With `raise_errors: false`
+  it returns the component with the `_error` in its broadcasts, so a spec that
+  expected `live_mount(..., raise_errors: false)` to raise now needs to assert
+  on `broadcasts(:_error)` instead. The default, `raise_errors: true`, still
+  raises (gem).
+- **`component.x` and `self.x` in a template didn't re-render when `x`
+  changed.** Dependency tracking only recorded bare names, so a part that read
+  a reactive variable as `component.theme` or `self.theme` was skipped when
+  `theme` changed and kept showing the old value. `self.x` also ran Kernel's
+  method of that name when there was one, so `self.open` raised. Both forms
+  now count as reads of the component (gem).
+- **A helper called with arguments rendered a template local of the same
+  name instead.** After `<% t = Time.current %>`, a later `<%= t('.title') %>`
+  printed the time: a call with arguments still found the stored local before
+  the helper. A local now only answers a bare name, as in plain ERB (gem).
+- **`items.each.with_index` raised `LocalJumpError` on reactive arrays.** A
+  reactive array's `each` always yielded, so calling `each` without a block
+  failed, and so did `each.with_index`, `each.with_object` and `each.lazy`. In
+  a template this meant the prerender worked, because it sees the raw array,
+  but every socket render failed and the component never went live. `each`
+  without a block now returns an enumerator, and elements yielded through it
+  are tracked like those from `each` with a block (gem).
+- **Some common ways of changing a reactive Array or Hash didn't re-render.**
+  Change tracking only knew the method names it listed, so aliases and
+  ActiveSupport bang methods went straight through untracked. That covered
+  `append`, `prepend`, `filter!`, `collect!`, `compact_blank!` and `extract!`,
+  and on hashes `store`, `replace`, `slice!`, `with_defaults!`,
+  `deep_symbolize_keys!` and others. Nested values read through `detect`,
+  `fetch`, `dig`, `at`, `min_by`, `each_with_index`, `each_with_object`,
+  `reverse_each`, `each_slice`, `values`, `each_value` or `Hash#each` came
+  back untracked. So `todos.detect { ... }[:done] = true` answered with an
+  `_ack` and left the page stale. All of these are now tracked, and a spec
+  fails if a mutating method is missed. Values yielded by these methods are
+  now tracked wrappers, like the ones `each` already yielded, so `is_a?(Hash)`
+  on them is false. The blocks of `map`/`select` and the results of
+  `to_a`/`to_h` are still untracked; see *Nested Structures* in the reactive
+  variables guide (gem).
+- **`self.tags = tags.dup` stopped all later change tracking for `tags`.**
+  `dup` dropped the wrapper's tracking modules, so the assignment rendered
+  once and every later `tags << x` or nested change went unnoticed. A
+  duplicated reactive value now keeps its tracking. `clone(freeze: false)` on
+  a reactive value or an ActiveRecord model raised `ArgumentError` and now
+  works (gem).
+- **Changing an element moved into another reactive collection marked the
+  wrong variable.** After `done << todos.find { ... }` (or `self.done =
+  [item]`, `done + [item]`, `selection[:item] = item`), changing the element
+  through `done` marked `todos` instead. That included a child component given
+  the element with `live(...)`, so the `done` part never re-rendered. Reactive
+  collections now store the plain element rather than the tracked wrapper it
+  was read through, and an element read back is tracked through the collection
+  it was read from. An Array or Hash you pass in is copied only when it holds
+  such a wrapper (gem).
+- **ActiveRecord models read from a reactive variable never compared equal.**
+  Two reads of the same record, or a raw record and a wrapped one, compared
+  unequal. So `todos.delete(todos.find { ... })` left the record in the list,
+  `include?`, `index` and `todos - [found]` missed it, and `t == selected` in
+  a template never matched. Equality now compares the records themselves.
+  Unsaved records still compare unequal, as ActiveRecord intends (gem).
+- **Many changes to ActiveRecord models in reactive variables didn't
+  re-render.** A model reached through a reactive Array or Hash
+  (`todos.first.title = x`, `todos.find { ... }.toggle!(:done)`, setters
+  inside `todos.each`) was only tracked for `update` and `assign_attributes`.
+  Even a model stored directly missed `[]=`, `write_attribute`, `increment!`,
+  `update_column(s)`, `reload` and saved in-place JSON changes, so the
+  streaming guide's `document.reload` example never refreshed the page. All of
+  these writes are now tracked, at any depth. A replaced record no longer
+  keeps marking the variable it was removed from. `reload`, and validations
+  that normalize attributes, now re-render even when nothing visible changed.
+  Association changes and unsaved in-place edits still need `dirty(:name)`
+  (gem).
+- **After connecting, reactive Arrays and Hashes rendered wrongly in Rails tag
+  helpers, and `where(id: reactive_array)` matched nothing.** A tracked value
+  isn't an `Array` or `Hash` to `case` or `===`. On socket renders,
+  `tag.span(class: classes)` printed `class="[&quot;btn&quot;,
+  &quot;primary&quot;]"` where the prerender printed `class="btn primary"`,
+  and `where(id: ids)` compiled to `id = NULL`. Templates now see the plain
+  value, so helpers and `case` behave as in any Rails view, and `where(column:
+  value)` accepts reactive values. A child given one of these with `live(...)`
+  still shares its change tracking, so the parent re-renders when the child
+  changes it. That covers a reactive value, an element of one, and a
+  collection built from one in the template, such as `todos.reject { ... }`. A
+  template that mutates a reactive value no longer marks it dirty. A
+  variable's first read now returns the tracked value like later reads, so
+  changes made through it are tracked. In component code, `case`,
+  `where(hash)` and association assignment still need `to_a`, `to_h` or
+  `__getobj__` (gem).
+- **A part that passed a reactive variable with hash shorthand (`render
+  'badge', page:`) or called it with empty parentheses (`count()`) never
+  re-rendered.** The dependency analysis only recognised a bare `page`, so
+  these forms (`tag.span(data: { page: })`, `items_path(page:)`, a shorthand
+  of a template local set in an earlier part) were left out and the part kept
+  its first-render HTML. Any receiverless call with no arguments and no block
+  now counts as a read. (gem)
+- **A component method's dependencies were lost when another def in the same
+  file had the same name.** The method analyzer parses the component's whole
+  file and the last def with a given name won, so a `def self.title`, a `class
+  << self` method, a method in a nested class or `Struct.new` block, or a
+  method of a second class in the file could leave every part calling `title`
+  stale. Same-named defs now merge their dependencies, and singleton methods
+  are ignored. Affected parts may now re-render where they were previously
+  skipped. (gem)
+- **Parts reading a non-reactive `shared` variable in a `.live.erb` template
+  never re-rendered.** They kept their first-render value even when the
+  component re-rendered for its own reasons or wrote the variable itself, so
+  the guide's FilterPanel badge example showed a stale count. Whenever a
+  component re-renders, parts that read its `shared` variables, directly or
+  through a component method, now re-render too. A change to a `shared`
+  variable on its own still does not trigger a render. These parts are now
+  sent on every re-render of the component. (gem)
+- **The guide's `reactive :user, ->(c) { User.find(c.defaults[:user_id]) }`
+  raised `NoMethodError`.** `Component#defaults` was private, and an initial
+  lambda gets the component as an explicit receiver. So the prerender failed,
+  `live_mount` raised, and a real subscribe sent an `_error` and rendered
+  without the default. `defaults` is now public. As a side effect, a bare
+  `defaults` in a `.live.erb` template now resolves to the component's hash
+  (gem).
+- **A top-level component could render one way on page load and another once
+  connected.** Its defaults come back from the browser as JSON on subscribe,
+  but the prerender used the raw Ruby values. A Symbol came back as a String
+  and nested hash keys as Strings. Since signing in 0.4.0 used plain
+  `JSON.generate`, a `Time` came back as its `to_s` and a record as
+  `"#<User:0x…>"`. LiveCable now signs each default's `as_json` form, as 0.3's
+  unsigned attribute did, and prerenders a top-level component with that same
+  form, so both renders agree. In development and test it logs a warning for
+  any default that isn't JSON-native. **Never pass a record to a top-level
+  component: its JSON form is every one of its attributes, readable in the
+  page.** The defaults are signed, not encrypted. Pass an id and load the
+  record in the component. A top-level component now gets the JSON form on the
+  HTTP prerender too. So `status: :open` is now `"open"` there, and
+  `user.name` on a passed record now raises on page load (a 500 in production)
+  instead of after connect. Children rendered by a parent and `live_mount`
+  defaults are unchanged (gem).
+- **An exception in a reactive variable's initial lambda was swallowed and the
+  variable stuck at `nil` (or `true`).** On a connected component the error
+  was reported, and then `handle_error`'s return value was stored as the
+  variable. That was `nil` for a child rendered inline and `true` for a
+  component with a channel, and the lambda never ran again. A child whose
+  lambda failed rendered blank, with nothing sent to the client, and a failed
+  shared variable stayed broken for every later sharer. The error now goes
+  through the normal handling for the render or action that read it, including
+  `rescue_from`, and nothing is stored, so the next read retries. A top-level
+  component's subscribe now sends just the `_error` (no trailing `_refresh`).
+  A child's failing initial value now replaces its parent with the error box.
+  A non-proc initial value now raises `ArgumentError` when the class loads
+  (gem).
+- **Initial lambdas ran again on every read during the HTTP prerender.** With
+  no connection, the reactive getter never kept the value, so a `.live.erb`
+  template ran the lambda once per reference, plus once for the render locals.
+  A query read three times ran four times, and `-> { SecureRandom.hex }` gave
+  a label's `for` and its input's `id` different values on the same page. The
+  value is now kept for the rest of that prerender (gem).
+- **`before_render` and `after_render` never ran for a child rendered by its
+  parent.** Render callbacks ran only when a component broadcast its own
+  render. A child rendered inside a connected parent was never rendered that
+  way: on page load its subscription found it already rendered and only
+  confirmed its status. So state a child derived in `before_render` showed its
+  initial value and went stale every time the parent rendered it again. A
+  child's render callbacks now run each time a connected parent renders it,
+  and an error in one replaces the parent with the error box. On page load the
+  parent renders the child before the child subscribes, so the child's render
+  callbacks run before its connect callbacks, without connection identifiers
+  such as `current_user`. A child whose `before_render` uses one will now
+  error its parent on page load. Render callbacks still don't run during the
+  HTTP prerender, which the lifecycle guide now says (gem).
+- **A checkbox with `live-reactive` could never be unchecked, and a `<select
+  multiple>` kept only its first choice.** `live-reactive` always sent the
+  input's `value`. For a checkbox that is its `value` attribute ("on" by
+  default), whether the box is checked or not. For a multiple select it is
+  only the first selected option. A checkbox now sends `true` or `false`, and
+  a `<select multiple>` sends an Array of the selected values. Radios, single
+  selects and text inputs still send their value as a String. If you were
+  reading "on" (or a custom `value` attribute) from a checkbox, you now get a
+  boolean (npm).
+
+### Changed
+
+- **A render that changed nothing on the page was still sent.** When a
+  reactive variable changed but no part of the template showed it - a shared
+  variable updated by another component, say - the component still sent a
+  `_refresh` with every part empty, and the client rebuilt and morphed it for
+  no visible change. Such a render is now skipped: its events still go out,
+  its render callbacks still run, and the message it answers gets an `_ack`.
+- **Every render over the socket built a controller, request and response.**
+  `Component#render` went through `ApplicationController.renderer`, which
+  builds all three each time - about a fifth of the render time of a small
+  component. A connection now builds them once, from the same renderer
+  defaults, and each render takes a fresh view from that controller, so
+  `content_for`, instance variables a template sets and memoized view helpers
+  still don't carry over. The HTTP prerender is unchanged (gem).
+
+## 0.4.0 - 2026-09-29
+
+### Upgrading from 0.3
+
+Upgrade the gem and the npm package together. Defaults are now signed, and
+the client forwards them as an opaque string; a 0.3 client sends them as an
+object, which the server treats as no defaults at all, so every component
+would mount without them.
+
+Pages rendered before the upgrade carry unsigned defaults too. They mount with
+no defaults until reloaded, so deploy at a quiet moment, or expect components
+on open tabs to come up empty.
+
+A component already live on the page is now built again when a Turbo visit
+renders it with different defaults. One whose defaults differ on every
+render - a timestamp, a random token - is therefore rebuilt on every visit
+instead of keeping its state; keep defaults to what the component is about,
+such as a record or an account.
+
+A shared variable is now writable from the client only if every component
+class that shares the name declares it `writable: true`. An application that
+shares a name as writable in one component and server-only in another will
+see `live-reactive` writes to it refused.
+
+### Security
+
+- **Defaults could set reactive variables that weren't writable.** Defaults
+  passed to `live(...)` are written into the page and sent back by the browser
+  when the component subscribes, and they were applied to any reactive
+  variable, writable or not. Anyone could edit the `live-defaults` attribute,
+  or send the subscribe frame by hand, and set a variable meant to be
+  server-only - a record id, a price, a tenant key - bypassing the check
+  `live-reactive` writes go through. Defaults are now signed with a key
+  derived from `secret_key_base` and bound to the component's `live_id`; an
+  edited, unsigned or borrowed blob applies no defaults
+  (`LiveCable::DefaultsSigner`). `LiveCable::Testing#live_mount` still takes a
+  plain hash.
+- **A component could keep acting for the previous page's defaults after a
+  Turbo visit.** When the new page rendered a component with the same id as
+  one already live, the client kept the existing subscription and never sent
+  the new page's defaults. A component whose id didn't include the account
+  stayed bound to the account it was first rendered for, and its actions ran
+  against that account under a URL for another. The client now compares the
+  signed defaults and, when they differ, replaces the subscription so the
+  server builds the component from the new ones; equal defaults keep today's
+  behaviour, state included. A Turbo preview of a cached page is ignored.
+  Defaults are signed with their keys sorted, so the same defaults always
+  produce the same blob.
+- **A client could write a shared variable that a component treats as
+  server-only.** Shared variables are one value per connection, but a
+  `live-reactive` write was checked only against the class it was sent
+  through. Because a client can subscribe any component, it could mount one
+  that shares `:account_id` as `writable: true` and set the value another
+  component shares without `writable:` (or with plain `shared`). A client may
+  now write a shared name only if every class that shares it declares it
+  `writable: true`. Other writes are refused with `Forbidden`. Apps that mix
+  writable and server-only declarations of the same shared name will see those
+  writes refused. In development with lazy loading, a class that hasn't loaded
+  yet doesn't count toward the rule (gem).
+
+### Fixed
+
+- **An action and a `stream_from` callback could run at the same time on one
+  connection.** ActionCable runs each message and each stream broadcast as a
+  separate job on a worker pool shared by the whole server, with nothing
+  keeping two jobs for one socket apart, and LiveCable's per-connection state
+  was read and written from both. An action that saved a record and then
+  pushed it onto a reactive array could have the save's own broadcast reload
+  the array in between, and the record appeared twice. Each connection's work
+  is now serialised by a re-entrant lock, held across an action or callback
+  and its render. A job waiting on a busy connection holds a worker while it
+  waits; see *Concurrency* in the architecture guide (gem).
+- **A click while the socket was down left its button disabled for good.**
+  ActionCable drops a message sent on a closed socket, and one sent after a
+  reconnect but before the re-subscribe is confirmed, and the loading state
+  had already started. Messages are now held until the subscription is
+  confirmed and sent in order, and the component reads
+  `data-live-status-value="disconnected"` meanwhile (npm).
+- **A loading state waited for ever when no reply came** - the server
+  stopping mid-message, on a deploy. After `LoadingState.timeout` (30 seconds)
+  with nothing heard it gives up, restores the DOM, drops any messages still
+  held for a reconnect, sets the status to `stalled` and dispatches a
+  `live:stalled` event. Messages still held when a component's element is
+  replaced, by a Turbo navigation say, keep their loading state on the new
+  element (npm).
+- **Events dispatched by a child rendered inline by its parent were dropped.**
+  Such a child has no channel of its own yet; its events were flushed and then
+  discarded. They now wait for the child's own subscription (gem).
+- **Component names that collide with a top-level constant failed obscurely.**
+  `instance_from_string` used `const_defined?`, which inherits, so a name like
+  `"string"` slipped past the "not found" guard and raised `NoMethodError`
+  instead of `LiveCable::Error` (gem).
+- **A `stream_from` callback re-sent whatever the last message had changed.**
+  Changesets were reset only when a client message arrived. Variables dirtied
+  by the last message, or by the defaults applied at subscribe, stayed dirty,
+  and every later stream callback on the socket re-rendered them, whichever
+  component of the connection they belonged to. In a chat whose input is a
+  component of its own, as in the streaming guide, each incoming message
+  re-rendered the input with its last-sent `live-reactive` value, and the
+  morph overwrote whatever had been typed since the last debounce. A stream
+  callback now resets the changesets before it runs, as a message does, so it
+  sends only what it changed (gem).
+- **Grandchild components went missing from the page.** A refresh replaced
+  the `<LiveCable>` placeholders in its own markup but not the ones inside a
+  child it had just built or rebuilt, so a grandchild reached the morph as an
+  empty element: a tree nested three deep lost its third level as soon as the
+  page connected, and a grandchild added by its parent's own refresh was torn
+  out the next time its grandparent re-rendered. Placeholders are now
+  replaced until none remain. A component that turns up twice in one refresh
+  keeps its first appearance and logs a console error, and a child with
+  nothing to rebuild from is left empty instead of abandoning the refresh
+  (npm).
+- **Rendering a partial with a block from a `.live.erb` template failed.**
+  The block was dropped on its way to the view, so
+  `<%= render layout: 'shared/card' do %>` raised `ArgumentError`, and
+  `<%= render 'shared/card' do %>` rendered the partial with nothing where it
+  yields. The block is now passed on and renders where the partial yields (gem).
+- **Rendering a `.live.erb` template as a partial put
+  `#<LiveCable::Rendering::Partial:0x...>` in the page.** A `.live.erb`
+  template compiles to an object only a component knows how to render, so
+  `<%= render 'shared/card' %>` on a `_card.html.live.erb`, or
+  `render template:` on one, wrote that object's escaped name into the HTML.
+  It now raises `LiveCable::Error`, saying to render the component with
+  `live(...)` or `render(component)`, or to make the partial a `.html.erb`
+  template (gem).
+- **A `stream_from` broadcast that arrived as its component disconnected
+  raised in ActionCable's worker.** ActionCable runs each broadcast as its own
+  job, so one queued before the stream was stopped still ran the callback
+  against the departed component; broadcasting its changes then raised
+  `NoMethodError` on the missing connection, and the rescue meant to report
+  that raised again, so the error escaped to ActionCable's log. Such a
+  callback is now ignored (gem).
+- **The test harness's `rendered` forgot the initial render after
+  `clear_broadcasts`.** It was rebuilt from the `_refresh` payloads still in
+  the broadcast log, so after a clear and an action it held only the parts
+  that action changed, and any inline child rendered earlier was missing.
+  Renders are now kept apart from the broadcast log, so `rendered` and
+  `rendered_html` reflect every render whatever has been cleared.
+  `broadcasts` and `dispatched_events` still start over after a clear (gem).
+- **The test harness's `rendered` left out grandchildren.** The results
+  for inline children at every depth arrive together in the root's refresh,
+  but a child's placeholders were resolved against a set of children of its
+  own, which was always empty. A component rendered inline by an inline child
+  came out blank. Placeholders now resolve at any depth (gem).
+- **Two components that subscribed at the same moment could end up on
+  different connections.** A socket's `LiveCable::Connection` is created the
+  first time it is needed, and ActionCable runs each subscribe as its own job
+  on its worker pool, so two components on one page subscribing together could
+  each create one. A component left on the losing one had its actions answered
+  with an `_ack` and no re-render, and shared reactive variables weren't
+  shared. The connection is now created under a lock (gem).
+- `MethodAnalyzer` no longer raises for a component class with no Ruby source
+  location, such as one built with `Class.new`. With no methods to analyze,
+  every part that calls one of the component's methods re-renders on each
+  change (gem).
+- `insert_root_attributes` builds a new string instead of mutating the
+  rendered part, so a frozen part can't raise `FrozenError`, and its "no root
+  element" error now shows the start of the offending output (gem).
+- **A component destroyed while a message was in flight stayed loading.**
+  `destroy` unsubscribes the component on the client, so the reply to the
+  message that caused it never arrived and its `live-disable-with` button
+  stayed disabled. The loading state is now cleared when the server destroys
+  the component (npm).
+
+### Added
+
+- **`rescue_from` in components.** `ActiveSupport::Rescuable` was included but
+  never consulted. An error raised by an action, a `live-reactive` write or a
+  `stream_from` callback is now offered to the component's `rescue_from`
+  handlers first; a handled error still answers the message, so the loading
+  state clears, and anything the handler set is re-rendered. Failures while
+  subscribing or rendering still get the default error markup, as does a
+  message asking for an action the component doesn't expose or a write to a
+  variable that isn't `writable:` - those raise `LiveCable::Forbidden`, a
+  `LiveCable::Error`, and are never offered to `rescue_from` (gem).
+- **`before_dispatch` callbacks.** Authorizing every client message meant
+  wrapping each action, keeping its arity, catching methods defined after
+  `actions`, and wrapping every writable variable's setter - which then also
+  ran for the component's own writes. `before_dispatch` runs before each
+  action call and `live-reactive` write the client sends, and before nothing
+  else: not server-side assignments, the defaults applied at subscribe, or
+  `stream_from` callbacks. `current_dispatch` says what is being dispatched
+  (`kind`, `name`, `params` or `value`). `throw :abort` skips the message and
+  still answers it, so the loading state clears; an error raised goes to
+  `rescue_from` like one raised by an action. Callbacks are inherited, so an
+  `ApplicationComponent` can declare one for every component (gem).
+- **`live_cable_identity_tag`, so a sign-in or sign-out in a tab moves its
+  socket on.** A socket is identified once, at its handshake, and Turbo keeps
+  it open across sign-in, sign-out and impersonation, all ordinary form
+  submissions; after user A signed out and user B signed in, every component
+  in the tab kept acting as A. The helper renders a meta tag carrying a keyed
+  digest of whatever the application identifies sockets by; when a Turbo
+  visit brings a different one, the client closes the socket and opens a new
+  one before the new page's components subscribe, and they come back as the
+  new session. Other tabs, and access revoked by someone else, are the
+  application's to handle with ActionCable's
+  `remote_connections.where(...).disconnect`; the architecture guide's
+  *Sign-in, Sign-out and Revocation* shows the Devise wiring.
+
+### Changed
+
+- Framework warnings - a component rendered without a `.live.erb` template, a
+  missing `app/live` directory - go through the Rails logger once per process,
+  instead of `Kernel#warn` to stderr on every render (gem).
+- RuboCop now fails CI.
+
 ## 0.3.0 - 2026-09-26
 
 ### Upgrading from 0.2

data/README.md

@@ -589,7 +589,7 @@ self.count.+(1)
 self.name.concat("Doe")
 ```
 
-For more details on the change tracking architecture, see [ARCHITECTURE.md](ARCHITECTURE.md).
+For more details on the change tracking architecture, see the [architecture guide](https://livecable.io/guide/architecture).
 
 ## Shared Variables
 
@@ -649,7 +649,7 @@ module Live
 end
 ```
 
-**Use case**: FilterPanel can read the cart to show item count in a badge, but doesn't need to re-render every time an item is added—only when the filter changes.
+**Use case**: FilterPanel can read the cart to show item count in a badge, but doesn't need to re-render every time an item is added—only when the filter changes. Whenever FilterPanel re-renders for its own reasons, parts that read `cart_items` (directly or through a method) re-render too, so the badge picks up the latest count.
 
 ## Action Whitelisting
 
@@ -897,6 +897,18 @@ Updates a reactive variable when an input changes. The corresponding reactive va
 <input type="text" name="query" live-reactive="keydown keyup">
 ```
 
+The value sent depends on the input: a checkbox sends `true` or `false` (whether it is checked, regardless of its `value` attribute), a `<select multiple>` sends an Array of the selected option values, and everything else, radio buttons included, sends its `value` as a String.
+
+```html
+<input type="checkbox" name="notify" live-reactive <%= 'checked' if notify %>>
+
+<select multiple name="tags" live-reactive="change">
+  <% %w[ruby rails].each do |tag| %>
+    <option value="<%= tag %>" <%= 'selected' if tags.include?(tag) %>><%= tag %></option>
+  <% end %>
+</select>
+```
+
 **Transformation:** `live-reactive` becomes `data-action="live#reactive"`, and `live-reactive="keydown"` becomes `data-action="keydown->live#reactive"`
 
 ### `live-debounce`