chats 0.1.1 → 0.3.1

data/app/assets/stylesheets/chats.css

@@ -11,6 +11,7 @@
  *   :root {
  *     --chats-accent: #facc15;          /\* brand color: own bubbles, send button *\/
  *     --chats-accent-contrast: #111827; /\* text on top of the accent *\/
+ *     --chats-verified: #0284c7;        /\* the "official account" badge *\/
  *   }
  *
  * Want a completely different look? `rails g chats:views` ejects the
@@ -26,6 +27,7 @@
   --chats-border: rgba(0, 0, 0, 0.08);
   --chats-text: #111827;
   --chats-text-muted: #6b7280;
+  --chats-verified: #0284c7;
   --chats-bubble-bg: #f3f4f6;
   --chats-bubble-text: #111827;
   --chats-radius: 1.1rem;
@@ -79,6 +81,12 @@
   justify-content: space-between;
   gap: 0.75rem;
 }
+.chats-row__name {
+  display: flex;
+  align-items: center;
+  gap: 0.25rem;
+  min-width: 0;
+}
 .chats-row__title {
   font-weight: 650;
   white-space: nowrap;
@@ -147,6 +155,34 @@
   user-select: none;
 }
 
+/* --- Verified messagers ------------------------------------------------------
+ *
+ * The "official account" mark (`acts_as_messager verified: true`). It sizes
+ * itself from the text it sits next to, so it reads right in an inbox row and
+ * in the thread header without either one hard-coding a pixel value. Recolour
+ * it with --chats-verified; replace the glyph with config.verified_badge.
+ *
+ * On #0284c7 rather than the more familiar #1d9bf0: the badge is a meaningful
+ * graphic, so WCAG 1.4.11 asks for 3:1 against what it sits on, and #1d9bf0
+ * is 3.00:1 on --chats-bg but only 2.73:1 on --chats-surface — which is the
+ * row hover background, so the mark failed exactly while someone was pointing
+ * at it. #0284c7 clears 3:1 on both (4.10 and 3.72) and on a dark ground too
+ * (4.33 on #111827), so a host that inverts the palette inherits a badge that
+ * still passes instead of one it has to remember to fix. Pinned by
+ * test/verified_badge_contrast_test.rb.
+ */
+.chats-verified {
+  flex-shrink: 0;
+  display: inline-flex;
+  align-items: center;
+  color: var(--chats-verified);
+  line-height: 0;
+}
+.chats-verified__glyph {
+  width: 1em;
+  height: 1em;
+}
+
 /* --- Thread -------------------------------------------------------------------- */
 
 .chats-thread {
@@ -179,6 +215,12 @@
   font-size: 1rem;
   font-weight: 750;
   margin: 0;
+  display: flex;
+  align-items: center;
+  gap: 0.25rem;
+  min-width: 0;
+}
+.chats-thread__name {
   white-space: nowrap;
   overflow: hidden;
   text-overflow: ellipsis;
@@ -816,3 +858,47 @@ turbo-frame[id^="chats_page_"] {
   border-radius: 0.5rem;
 }
 .chats-emoji:hover { background: var(--chats-surface); }
+
+/* ---------------------------------------------------------------------------
+   0.2.0 — stacked inbox rows, locked composers, signed messages
+   --------------------------------------------------------------------------- */
+
+/* A stack (Chats::InboxGroup) reads as one row; the count line sits where a
+   single conversation shows its subject. */
+.chats-row--group .chats-row__subject { font-weight: 600; }
+
+/* The inbox filtered to one counterpart (?with=). */
+.chats-inbox__filter {
+  display: flex;
+  align-items: baseline;
+  gap: 0.5rem;
+  margin: 0 0 0.5rem;
+  font-size: 0.85rem;
+  color: var(--chats-text-muted);
+}
+.chats-inbox__filter-clear { color: inherit; text-decoration: underline; }
+
+/* "See all" back to the stack, under the thread title. */
+.chats-thread__see-all { margin: 0; font-size: 0.72rem; }
+.chats-thread__see-all-link { color: var(--chats-text-muted); text-decoration: underline; }
+
+/* Who wrote it, when that isn't the seat it came from. */
+.chats-message__signature {
+  margin-top: 0.25rem;
+  font-size: 0.7rem;
+  font-style: italic;
+  opacity: 0.75;
+}
+
+/* The composer, replaced by the reason the conversation is closed. Same box,
+   so the thread doesn't jump when a subject locks under an open composer. */
+.chats-composer--locked {
+  display: block;
+  padding: 0.85rem 1rem;
+  text-align: center;
+}
+.chats-composer__locked-notice {
+  margin: 0;
+  font-size: 0.85rem;
+  color: var(--chats-text-muted);
+}

data/app/controllers/chats/conversations_controller.rb

@@ -5,16 +5,22 @@ module Chats
   # pages (create), and the per-member actions (read/typing/leave/mute).
   class ConversationsController < ApplicationController
     before_action :set_conversation, only: %i[show read typing leave mute unmute refresh]
+    helper_method :chats_counterpart
 
     # The inbox. Everything is preloaded/batched so rendering N rows costs a
     # constant number of queries (conversations + last messages + participants
     # + one grouped unread-count query — see Conversation.unread_counts_for).
+    # Rows are Conversation | InboxGroup: stacking, search and the `?with=`
+    # filter all live in Chats::Inbox, so this action stays three lines.
     def index
-      @conversations = chats_current_messager.chats
-                                             .includes(:last_message, :subject, participants: :messager)
-                                             .limit(200)
-      @conversations = apply_search(@conversations)
-      @unread_counts = Chats::Conversation.unread_counts_for(chats_current_messager, @conversations)
+      @inbox = Chats::Inbox.for(chats_current_messager, query: params[:q], with: inbox_filter)
+      @rows = @inbox.rows
+      @unread_counts = @inbox.unread_counts
+      # Back-compat for inboxes ejected under 0.1.x, which loop over
+      # @conversations: they keep rendering the flat list (no stacking, i.e.
+      # exactly what they rendered before). Re-eject or delete your copy to
+      # get the stacked rows.
+      @conversations = @inbox.conversations
     end
 
     # The thread. Renders the LATEST page of messages; older pages stream in
@@ -76,11 +82,18 @@ module Chats
       # A backlog deeper than one page would mean splicing an arbitrary
       # amount of history through surgical appends; a Turbo 8 page refresh
       # (morph + scroll preservation) re-renders the latest page + frame
-      # chain correctly instead. Raw tag rather than `turbo_stream.refresh`
-      # so we don't depend on turbo-rails ≥ 2.0 helpers.
+      # chain correctly instead.
+      #
+      # `render turbo_stream:`, NOT `render html: … content_type:` — the
+      # latter forces text/html and silently ignores the content type, so the
+      # body says <turbo-stream> while the response says it isn't one.
+      #
+      # `request_id: nil` on purpose: Turbo skips a refresh tagged with a
+      # request id it recognizes as its own, and this response is the answer
+      # to the client's OWN catch-up fetch — the one client that must not
+      # skip it.
       if @new_messages.size > Chats.config.messages_per_page
-        render html: '<turbo-stream action="refresh"></turbo-stream>'.html_safe,
-               content_type: "text/vnd.turbo-stream.html"
+        render turbo_stream: turbo_stream.refresh(request_id: nil)
         return
       end
 
@@ -156,43 +169,27 @@ module Chats
       GlobalID::Locator.locate_signed(sgid, for: purpose) || raise(ActiveRecord::RecordNotFound)
     end
 
-    # Partial, case-insensitive matching across the inbox metadata users can
-    # actually see: participant names, conversation titles, subject labels,
-    # and message bodies. The inbox is capped at 200 rows, so metadata is
-    # filtered portably in Ruby from the already-preloaded objects while the
-    # potentially larger message-body set stays in SQL. No PostgreSQL-only
-    # full-text dependency is needed for this scale.
-    def apply_search(conversations)
-      return conversations unless Chats.config.search
-
-      query = params[:q].to_s.strip
-      return conversations if query.empty?
-
-      loaded = conversations.to_a
-      normalized_query = query.downcase
-      pattern = "%#{Chats::Conversation.sanitize_sql_like(query.downcase)}%"
-      message_match_ids =
-        if Chats.config.encrypt_messages
-          []
-        else
-          Chats::Message.where(conversation_id: loaded.map(&:id), deleted_at: nil)
-                        .where("LOWER(chats_messages.body) LIKE ?", pattern)
-                        .distinct
-                        .pluck(:conversation_id)
-        end
+    # `?with=<signed gid>` — the inbox filtered to one counterpart (a stack's
+    # contents). Signed and purpose-scoped like every other polymorphic
+    # param the engine accepts; a tampered one is a plain 404.
+    def inbox_filter
+      return nil if params[:with].blank?
 
-      loaded.select do |conversation|
-        message_match_ids.include?(conversation.id) ||
-          searchable_metadata(conversation).downcase.include?(normalized_query)
-      end
+      messager = locate_signed!(params[:with], purpose: :chats_inbox_with)
+      raise ActiveRecord::RecordNotFound unless Chats.messager_class?(messager.class)
+
+      messager
     end
 
-    def searchable_metadata(conversation)
-      participant_names = conversation.participants.filter_map do |participant|
-        Chats.display_name_for(participant.messager) if participant.active?
-      end
+    # The other party of a direct thread (nil for groups) — the thread header
+    # names them, links to their profile, and decides whether to offer the
+    # "see all" link back to their stack. LAZY and memoized: a group thread
+    # never pays for it, and a direct one pays once no matter how many of
+    # those three things the rendered view asks for.
+    def chats_counterpart
+      return @chats_counterpart if defined?(@chats_counterpart)
 
-      [conversation.title, conversation.subject_label, *participant_names].compact.join(" ")
+      @chats_counterpart = @conversation&.counterpart_for(chats_current_messager)
     end
   end
 end

data/app/controllers/chats/messages_controller.rb

@@ -6,6 +6,11 @@ module Chats
     before_action :set_conversation
     before_action :set_message, only: %i[show update destroy]
     before_action :require_ownership!, only: %i[update destroy]
+    # A locked conversation refuses every write, not just new messages.
+    # `create` is NOT in this list: its own validation produces the same
+    # response, and going through the model keeps the "locked since you
+    # opened the composer" race in one place.
+    before_action :refuse_when_locked!, only: %i[update destroy]
 
     # Per-sender send throttle via Rails 8's built-in controller rate
     # limiting (https://api.rubyonrails.org/classes/ActionController/RateLimiting.html).
@@ -40,6 +45,17 @@ module Chats
           format.turbo_stream
           format.html { redirect_to conversation_path(@conversation) }
         end
+      elsif locked?
+        # The subject closed the conversation (Chats::ChatSubject#
+        # chat_locked?) — possibly while this composer sat open. Swap the
+        # composer for the locked notice instead of flashing an error at
+        # someone whose screen is now lying to them. 422, never a raise.
+        respond_to do |format|
+          format.turbo_stream { render :locked, status: :unprocessable_entity }
+          format.html do
+            redirect_to conversation_path(@conversation), alert: @conversation.locked_notice
+          end
+        end
       else
         respond_to do |format|
           format.turbo_stream { render :errors, status: :unprocessable_entity }
@@ -85,6 +101,24 @@ module Chats
       @conversation = find_conversation(params[:conversation_id])
     end
 
+    # Did THIS save fail because the conversation is locked? Reads the error
+    # type, not the conversation, so a message that also failed validation
+    # for another reason still reports that reason.
+    def locked?
+      @message.errors.of_kind?(:base, :locked)
+    end
+
+    # Gate the action, explain it in place: the composer becomes the locked
+    # notice (422), or a plain redirect carrying the notice without Turbo.
+    def refuse_when_locked!
+      return unless @conversation.locked?
+
+      respond_to do |format|
+        format.turbo_stream { render :locked, status: :unprocessable_entity }
+        format.html { redirect_to conversation_path(@conversation), alert: @conversation.locked_notice }
+      end
+    end
+
     def set_message
       @message = @conversation.messages.find(params[:id])
     end

data/app/controllers/chats/reactions_controller.rb

@@ -9,6 +9,7 @@ module Chats
     def create
       conversation = find_conversation(params[:conversation_id])
       message = conversation.messages.find(params[:message_id])
+      return refuse_when_locked(conversation) if conversation.locked?
 
       Chats::Reaction.toggle!(
         message: message,
@@ -29,5 +30,18 @@ module Chats
     rescue ActiveRecord::RecordInvalid
       head :unprocessable_entity
     end
+
+    private
+
+    # Same shape as the messages controller: swap the composer for the
+    # reason, 422, never an exception page.
+    def refuse_when_locked(conversation)
+      @conversation = conversation
+
+      respond_to do |format|
+        format.turbo_stream { render "chats/messages/locked", status: :unprocessable_entity }
+        format.html { redirect_to conversation_path(conversation), alert: conversation.locked_notice }
+      end
+    end
   end
 end

data/app/helpers/chats/engine_helper.rb

@@ -5,6 +5,17 @@ module Chats
   # HOST app's views (mixed into ActionView via the engine's on_load hook,
   # the same pattern the moderate gem uses for `report_link`).
   module EngineHelper
+    # Every slot the bundled views render, and the whole list of them. A
+    # host drops `app/views/chats/slots/_<name>.html.erb` in and it appears;
+    # a name that isn't here renders nothing.
+    SLOTS = %w[
+      inbox_top
+      inbox_empty
+      conversation_header_actions
+      locked_composer
+      message_meta
+    ].freeze
+
     # The "message this person" affordance for host pages — a listing, a
     # profile, an order. Renders nothing when there's no viewer, the viewer
     # IS the target, or policy/blocks forbid the pair, so it's always safe
@@ -117,8 +128,7 @@ module Chats
     # initials disc from the group name.
     def chats_conversation_avatar(conversation, viewer)
       if conversation.direct?
-        other = conversation.other_participants(viewer).first
-        chats_messager_avatar(other&.messager)
+        chats_messager_avatar(conversation.counterpart_for(viewer))
       else
         initials = conversation.title_for(viewer).split.first(2).map { |word| word[0] }.join.upcase
         tag.span(initials.presence || "👥", class: "chats-avatar chats-avatar--initials chats-avatar--group",
@@ -126,6 +136,107 @@ module Chats
       end
     end
 
+    # --- Slots ----------------------------------------------------------------
+    #
+    # Named extension points the bundled views render WHEN a partial exists
+    # at `chats/slots/_<name>`. Hosts (and engines mounted on top of chats,
+    # like support_desk) drop a file in and it appears; nobody has to eject
+    # a whole screen to add one row or one button. Absent slots cost one
+    # memoized template lookup and render nothing.
+    #
+    #   app/views/chats/slots/_inbox_top.html.erb
+    #
+    # The slots: inbox_top, inbox_empty, conversation_header_actions,
+    # locked_composer, message_meta.
+    def chats_slot(name, **locals)
+      return unless chats_slot?(name)
+
+      render(partial: "chats/slots/#{name}", locals: locals)
+    end
+
+    # Whether a slot partial exists. Memoized per view instance, so a slot
+    # rendered inside a collection costs ONE lookup per request, not one per
+    # row. Anything outside SLOTS is ignored rather than looked up: the slot
+    # names are a contract, and a typo should render nothing instead of
+    # quietly becoming a new extension point nobody documented.
+    def chats_slot?(name)
+      key = name.to_s
+      return false unless Chats::EngineHelper::SLOTS.include?(key)
+
+      @chats_slots ||= {}
+      return @chats_slots[key] if @chats_slots.key?(key)
+
+      @chats_slots[key] = lookup_context.exists?("chats/slots/#{key}", [], true)
+    end
+
+    # --- Messager display -----------------------------------------------------
+
+    # Whether block/report affordances apply to this messager. False for
+    # `acts_as_messager blockable: false` (a support desk, a bot) — the
+    # bundled views hide the affordance instead of asking hosts to branch on
+    # class.
+    def chats_blockable?(messager)
+      Chats.blockable?(messager)
+    end
+
+    # A messager's profile URL per `config.messager_url`, or nil.
+    def chats_messager_url(messager)
+      Chats.messager_url_for(messager)
+    end
+
+    # A messager's name, linked to their profile when `config.messager_url`
+    # gives one and plain text when it doesn't — so the gem never renders a
+    # dead anchor or assumes a `user_path` exists.
+    def chats_messager_name(messager, css_class: nil)
+      name = Chats.display_name_for(messager)
+      url = chats_messager_url(messager)
+
+      url.present? ? link_to(name, url, class: css_class) : tag.span(name, class: css_class)
+    end
+
+    # The "official account" mark for a messager declared `acts_as_messager
+    # verified: true`, and NIL for everyone else — so any view, bundled or
+    # host, can drop it next to a name unconditionally:
+    #
+    #   <%= chats_messager_name(author) %><%= chats_verified_badge(author) %>
+    #
+    # `config.verified_badge` swaps the glyph for the host's own design
+    # system; the default renders `chats/shared/_verified_badge`, whose
+    # colour is the `--chats-verified` CSS variable.
+    def chats_verified_badge(messager)
+      return unless Chats.verified?(messager)
+
+      custom = Chats.config.verified_badge
+      return custom.call(messager) if custom
+
+      render(partial: "chats/shared/verified_badge", locals: { messager: messager })
+    end
+
+    # The signature line under a signed message ("— Lucía G."), or nil.
+    def chats_message_signature(message)
+      Chats.message_signature_for(message)
+    end
+
+    # --- Grouped inbox rows ---------------------------------------------------
+
+    # Where a stacked inbox row goes: straight to the thread when the stack
+    # holds exactly one conversation, otherwise to the stack itself.
+    def chats_group_path(group)
+      return chats_routes.conversation_path(group.conversation) if group.single?
+
+      chats_group_path_for(group.messager)
+    end
+
+    # The stack list for a messager: the host's `group_path:` callable when
+    # `acts_as_messager` declared one (support_desk points it at its own
+    # screen), else chats' own filtered inbox.
+    def chats_group_path_for(messager)
+      custom = messager.class.try(:chat_group_path)
+      path = custom&.call(chats_viewer)
+
+      path.presence || chats_routes.conversations_path(with: Chats.inbox_with_sgid(messager))
+    end
+
     # The gem's bundled stylesheet (CSS-variable themed — see chats.css).
     # Called from the engine's own views; hosts that eject + restyle the
     # views with their own framework simply don't include it.

data/app/javascript/chats/refresh_inbox_controller.js

@@ -0,0 +1,86 @@
+import { Controller } from "@hotwired/stimulus"
+
+// chats--refresh-inbox — heals the inbox after a MISSED broadcast.
+//
+// The inbox updates via Turbo 8 page-refresh broadcasts
+// (Chats::Broadcasts.refresh_inbox_of → broadcast_refresh_later_to). Action
+// Cable has no replay: a refresh broadcast sent while this client's socket
+// was down (backgrounded tab/app, network blip, laptop asleep) is gone
+// forever, and the inbox silently sits at its last render until the user
+// happens to navigate. This controller re-runs the SAME page refresh on the
+// two moments we might have missed one — the socket reconnecting, and the
+// tab becoming visible again after long enough that the socket was reaped.
+//
+// It deliberately reuses chats--thread's reconnect/visibility detection (the
+// gem-native approach: observe the <turbo-cable-stream-source> `connected`
+// attribute rather than stand up a dedicated HeartbeatChannel — the attribute
+// IS the heartbeat). The difference is the recovery action: the thread does an
+// HTTP `?since=` delta because it patches messages surgically, whereas the
+// inbox already broadcasts whole-page refreshes, so the catch-up is just
+// `Turbo.session.refresh()` — idempotent, morphing, scroll-preserving.
+//
+// Registered automatically under the identifier "chats--refresh-inbox" via
+// the engine's importmap pin (see config/importmap.rb + Chats::Engine).
+//
+// Doctrine: Turbo Stream delivery is a best-effort enhancement; the page must
+// be correct without it. https://turbo.hotwired.dev/handbook/streams
+const REFRESH_AFTER_HIDDEN_MS = 60_000
+
+export default class extends Controller {
+  connect() {
+    this.streamDropped = false
+    this.hiddenAt = null
+    document.addEventListener("visibilitychange", this.visibilityChanged)
+    this.watchStreamSource()
+  }
+
+  disconnect() {
+    document.removeEventListener("visibilitychange", this.visibilityChanged)
+    this.sourceObserver?.disconnect()
+  }
+
+  visibilityChanged = () => {
+    if (document.visibilityState === "visible") {
+      // Hidden long enough that the socket may have been reaped → catch up
+      // on whatever the missed broadcasts would have refreshed.
+      if (this.hiddenAt && Date.now() - this.hiddenAt > REFRESH_AFTER_HIDDEN_MS) {
+        this.refresh()
+      }
+      this.hiddenAt = null
+    } else {
+      this.hiddenAt = Date.now()
+    }
+  }
+
+  // Reconnect detection without a dedicated cable channel: turbo-rails toggles
+  // a `connected` attribute on <turbo-cable-stream-source> as the Action Cable
+  // subscription confirms/drops, so observing it IS the heartbeat. A refresh
+  // that morphs the page can momentarily strip the attribute — harmless here:
+  // it only arms `streamDropped`, and the next genuine reconnect does one
+  // (cheap, idempotent) catch-up refresh.
+  watchStreamSource() {
+    const source = this.element.querySelector("turbo-cable-stream-source")
+    if (!source || typeof MutationObserver === "undefined") return
+
+    this.sourceObserver = new MutationObserver(() => {
+      const connected = source.hasAttribute("connected")
+      if (connected && this.streamDropped) {
+        this.streamDropped = false
+        this.refresh()
+      } else if (!connected) {
+        this.streamDropped = true
+      }
+    })
+    this.sourceObserver.observe(source, { attributes: true, attributeFilter: ["connected"] })
+  }
+
+  refresh() {
+    if (document.visibilityState !== "visible") return
+    // Don't morph the list out from under someone typing in the search box —
+    // the next trigger (or their own submit) will catch it up.
+    const active = document.activeElement
+    if (active && active.matches("input, textarea, select")) return
+
+    window.Turbo?.session?.refresh(document.baseURI)
+  }
+}

data/app/views/chats/conversations/_conversation_row.html.erb

@@ -7,7 +7,13 @@
 
     <span class="chats-row__body">
       <span class="chats-row__top">
-        <span class="chats-row__title"><%= conversation.title_for(viewer) %></span>
+        <%# The badge sits OUTSIDE the ellipsizing title so a long name
+            truncates without ever eating the mark. Nil for an ordinary
+            counterpart and for groups, so the row is unchanged. %>
+        <span class="chats-row__name">
+          <span class="chats-row__title"><%= conversation.title_for(viewer) %></span>
+          <%= chats_verified_badge(conversation.counterpart_for(viewer)) %>
+        </span>
         <time class="chats-row__time" datetime="<%= conversation.last_message_at&.iso8601 %>">
           <%= chats_timestamp(conversation.last_message_at) %>
         </time>

data/app/views/chats/conversations/_group.html.erb

@@ -0,0 +1,41 @@
+<%# One STACKED inbox row: every direct conversation the viewer has with a
+    `acts_as_messager inbox: :grouped` counterpart (a support desk, a
+    storefront), folded into a single line — their avatar and name, the
+    freshest message across the stack, and the aggregate unread badge.
+
+    A stack of one links straight to that thread (and the thread offers a
+    "see all" link back here); a deeper stack opens the stack list, which is
+    either the host's `group_path:` or chats' own filtered inbox. %>
+<li class="chats-row chats-row--group <%= "chats-row--unread" if group.unread? %>"
+    id="<%= group.dom_id %>">
+  <%= link_to chats_group_path(group), class: "chats-row__link" do %>
+    <%= chats_messager_avatar(group.messager) %>
+
+    <span class="chats-row__body">
+      <span class="chats-row__top">
+        <span class="chats-row__name">
+          <span class="chats-row__title"><%= group.title_for(viewer) %></span>
+          <%= chats_verified_badge(group.messager) %>
+        </span>
+        <time class="chats-row__time" datetime="<%= group.last_message_at&.iso8601 %>">
+          <%= chats_timestamp(group.last_message_at) %>
+        </time>
+      </span>
+
+      <% if group.open_count > 1 %>
+        <span class="chats-row__subject"><%= t("chats.inbox.group_count", count: group.open_count) %></span>
+      <% elsif group.conversation&.subject_label %>
+        <span class="chats-row__subject"><%= group.conversation.subject_label %></span>
+      <% end %>
+
+      <span class="chats-row__bottom">
+        <span class="chats-row__preview">
+          <%= group.conversation ? chats_preview_for(group.conversation, viewer) : "" %>
+        </span>
+        <% if group.unread? %>
+          <span class="chats-badge"><%= group.unread_count > 99 ? "99+" : group.unread_count %></span>
+        <% end %>
+      </span>
+    </span>
+  <% end %>
+</li>

data/app/views/chats/conversations/_locked_composer.html.erb

@@ -0,0 +1,15 @@
+<%# What sits where the composer would be when the conversation's SUBJECT
+    has locked it (Chats::ChatSubject#chat_locked?). It carries the same DOM
+    id as the composer form, so MessagesController#create can swap one for
+    the other with a single Turbo replace when a thread closes under an open
+    composer.
+
+    The `locked_composer` slot replaces the BODY (a reopen button, a link to
+    the closed ticket…) while keeping the id contract intact. %>
+<div id="<%= dom_id(conversation, :composer) %>" class="chats-composer chats-composer--locked">
+  <% if chats_slot?(:locked_composer) %>
+    <%= chats_slot :locked_composer, conversation: conversation, notice: conversation.locked_notice %>
+  <% else %>
+    <p class="chats-composer__locked-notice"><%= conversation.locked_notice %></p>
+  <% end %>
+</div>