chats 0.4.2 → 0.5.1

data/app/controllers/chats/conversations_controller.rb

@@ -2,8 +2,19 @@
 
 module Chats
   # The inbox (index), the thread (show), starting conversations from host
-  # pages (create), and the per-member actions (read/typing/leave/mute).
+  # pages (create), the messaging dock's recent list (dock), and the
+  # per-member actions (read/typing/leave/mute).
   class ConversationsController < ApplicationController
+    # The most rows the dock's recent list shows, whatever `recent:` asks.
+    DOCK_RECENT_LIMIT = 50
+    # How far before its list of what exists a catch-up stops naming
+    # deletions (see #present_messages).
+    PRESENT_MARGIN = 10.seconds
+    # The most ids a catch-up cursor may name, and the longest id (a UUID is
+    # 36): a client past either gets its history re-rendered instead.
+    CURSOR_IDS_LIMIT = 200
+    CURSOR_ID_LENGTH = 64
+
     before_action :set_conversation, only: %i[show read typing leave mute unmute refresh]
     helper_method :chats_counterpart
 
@@ -13,6 +24,11 @@ module Chats
     # Rows are Conversation | InboxGroup: stacking, search and the `?with=`
     # filter all live in Chats::Inbox, so this action stays three lines.
     def index
+      # The dock's search form posts here, so that without JavaScript it
+      # lands on the full inbox's results; from the dock's frame, the answer
+      # is the dock's own list.
+      return dock if turbo_frame_request_id == "chats_dock_list"
+
       @inbox = Chats::Inbox.for(chats_current_messager, query: params[:q], with: inbox_filter)
       @rows = @inbox.rows
       @unread_counts = @inbox.unread_counts
@@ -23,22 +39,41 @@ module Chats
       @conversations = @inbox.conversations
     end
 
+    # The messaging dock's recent list (`chats_dock`): the first rows of the
+    # viewer's inbox — the same rows, stacks and search, through the same
+    # Chats::Inbox — rendered into the dock's `chats_dock_list` frame. The
+    # frame asks for `?recent=` rows (the helper's `recent:` option).
+    def dock
+      @inbox = Chats::Inbox.for(chats_current_messager, query: params[:q], limit: dock_recent)
+      @rows = @inbox.rows
+      @unread_counts = @inbox.unread_counts
+
+      render :dock, layout: false
+    end
+
+    # The viewer's unread badges as a Turbo Stream: the nav badge
+    # (`chats_unread_badge`) and every badge in the dock, replaced with the
+    # same count the badge streams send. What a page asks for when it may
+    # have missed them (chats/recovery: a reconnect, a return to a hidden
+    # page, a restored page). Reads nothing, writes nothing.
+    def badge
+      render :badge, formats: :turbo_stream, locals: { count: chats_current_messager.unread_chats_count }
+    end
+
     # The thread. Renders the LATEST page of messages; older pages stream in
     # through a lazy Turbo Frame chain (keyset-paginated — see
     # Message.before_message and _messages_page.html.erb).
+    #
+    # `?window=1` from a Turbo frame is the same thread as a floating dock
+    # window: the window template (its compact header around the same
+    # thread body), no layout.
     def show
       @participant = @conversation.participant_for(chats_current_messager)
 
       anchor = params[:before].present? ? @conversation.messages.find_by(id: params[:before]) : nil
-      scope = @conversation.messages.includes(:sender, :reactions)
-      scope = scope.with_attached_files if scope.respond_to?(:with_attached_files)
+      scope = rendered_messages
       scope = scope.before_message(anchor) if anchor
-
-      # Fetch newest-first + reverse so "the last N messages" render in
-      # chronological order. One extra record peeks whether older pages exist.
-      page = scope.recent_first.limit(Chats.config.messages_per_page + 1).to_a
-      @more_messages = page.size > Chats.config.messages_per_page
-      @messages = page.first(Chats.config.messages_per_page).reverse
+      @messages, @more_messages = latest_page_of(scope)
 
       if anchor
         # Older-page request from the pagination frame: render just the page.
@@ -46,58 +81,69 @@ module Chats
                locals: { conversation: @conversation, messages: @messages, more: @more_messages }
       else
         # The «new messages» divider: computed BEFORE read! advances the
-        # horizon (after it, nothing is unread anymore). Anchored to the
-        # oldest unread bubble on the rendered page; when the backlog runs
-        # deeper than one page it pins to the top of the page instead —
-        # the scroll-up frame chain holds the rest.
-        if @participant&.unread?
-          @first_unread_id = @participant.unread_messages.where(id: @messages.map(&:id)).oldest_first.pick(:id) ||
-                             @messages.first&.id
-        end
+        # horizon (after it, nothing is unread anymore).
+        @first_unread_id = first_unread_id(@participant, @messages)
 
-        # Opening the thread reads it. (Live appends while the thread stays
-        # open are read via the thread controller's POST to #read.)
-        @participant&.read!
+        if dock_window?
+          # A window does NOT read on render: it may be restored minimized
+          # after a reload, and a header nobody has looked at must not
+          # swallow the unread badge. The thread controller posts #read once
+          # the window is actually on screen (`read-pending`).
+          render :window, layout: false
+        elsif !prefetch?
+          # Opening the thread reads it. (Live appends while the thread
+          # stays open are read via the thread controller's POST to #read.)
+          @participant&.read!
+        end
       end
     end
 
-    # Stale-thread catch-up: appends messages created — and replaces ones
-    # edited/tombstoned — since the newest `updated_at` the client has
-    # rendered (`?since=` in ms). The thread controller calls this when the
-    # tab wakes from a long sleep or its Turbo Stream subscription
-    # reconnects, i.e. whenever broadcasts may have been missed. Mobile
-    # WebViews suspend WebSockets aggressively, so without this a
-    # backgrounded chat silently loses messages until a manual reload.
-    # Pattern from Basecamp's Campfire (Rooms::RefreshesController):
-    # https://github.com/basecamp/once-campfire
+    # Stale-thread catch-up, on the client's cursors (see Message's catch-up
+    # scopes): `after=` µs and `after_ids=`, its newest creation and the ids
+    # it has at that moment (0 and none for an empty thread); `changed=` µs
+    # and `changed_ids=`, its newest change; `from=` µs, its oldest bubble's
+    # creation. Bubbles ejected before they carried these send `since=` ms
+    # alone, and are answered as they always were. The thread
+    # controller calls this whenever chats/recovery says the stream may have
+    # missed something: a reconnect, a return after 10 seconds hidden, the
+    # network back, a restored page. Mobile WebViews suspend WebSockets
+    # aggressively, so without this a backgrounded chat silently loses
+    # messages until a manual reload. Pattern from Basecamp's Campfire
+    # (Rooms::RefreshesController): https://github.com/basecamp/once-campfire
+    #
+    # The answer touches the history only, never the composer or its draft:
+    # messages created since are appended, ones changed since (edits,
+    # tombstones, reactions) replaced, the read state replaced, and — under
+    # `deletion: :hard` — the bubbles that no longer exist removed. Reads
+    # nothing: catching up is not reading (the controller posts #read once
+    # the viewer can see the new messages).
+    #
+    # `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.
     def refresh
-      head :no_content and return if params[:since].blank?
+      head :no_content and return if params[:changed].blank? && params[:since].blank?
 
-      since = Time.zone.at(0, params[:since].to_i, :millisecond)
-      scope = @conversation.messages.includes(:sender, :reactions)
-      scope = scope.with_attached_files if scope.respond_to?(:with_attached_files)
-
-      @new_messages = scope.created_since(since).oldest_first.limit(Chats.config.messages_per_page + 1).to_a
-
-      # 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.
-      #
-      # `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 turbo_stream: turbo_stream.refresh(request_id: nil)
-        return
-      end
+      # A client whose cursors name more than the limit (a busy thread whose
+      # live bubbles piled up since it last caught up, or a forged request)
+      # is answered with what is cheap at any size: the latest page.
+      return render_from_scratch if cursors_over_limit?
+
+      scope = rendered_messages
+      new_messages, @updated_messages = catch_up_on(scope)
+      @new_messages = new_messages.oldest_first.limit(Chats.config.messages_per_page + 1).to_a
 
-      @updated_messages = scope.updated_since(since)
+      # More than a page behind: splicing an arbitrary backlog through
+      # surgical appends would leave a hole in the scroll-up chain. Re-render
+      # the history at the latest page instead, exactly as opening the thread
+      # does, frame chain included. A thread view ejected before the history
+      # had its id (no `history=1`) gets the page refresh it always got;
+      # `request_id: nil`, because Turbo skips a refresh tagged with a request
+      # of its own, and this one answers the client's own catch-up.
+      return render_from_scratch if @new_messages.size > Chats.config.messages_per_page
+
+      @caught_up = caught_up_cursors if params[:changed].present?
+      @present = present_messages if Chats.config.deletion == :hard && params[:from].present?
       render "chats/conversations/refresh", formats: :turbo_stream
     end
 
@@ -106,6 +152,12 @@ module Chats
     # `chat_button_to` helper — unforgeable and purpose-scoped, so raw
     # polymorphic params never reach `GlobalID::Locator`. Policy and block
     # checks still run inside `chat_with` (defense in depth).
+    #
+    # `dock=1` (`chat_button_to …, dock: true`) answers a Turbo Stream that
+    # appends the conversation's floating window to the dock instead of
+    # navigating. Same id, so a window already open is replaced, not
+    # doubled; on a page without the dock the stream has no target and does
+    # nothing. Without Turbo it is the plain redirect.
     def create
       recipient = locate_signed!(params.require(:recipient_sgid), purpose: :chats_recipient)
       raise ActiveRecord::RecordNotFound unless Chats.messager_class?(recipient.class)
@@ -114,7 +166,16 @@ module Chats
                 locate_signed!(params[:subject_sgid], purpose: :chats_subject)
 
       conversation = chats_current_messager.chat_with(recipient, about: subject)
-      redirect_to conversation_path(conversation)
+
+      if params[:dock].present? && request.format.turbo_stream?
+        render turbo_stream: turbo_stream.append(
+          "chats_dock_windows",
+          partial: "chats/dock/window",
+          locals: { conversation: conversation, focus: true }
+        )
+      else
+        redirect_to conversation_path(conversation)
+      end
     rescue Chats::BlockedError
       # Fallback is the INBOX (engine root) — inside the engine, `root_path`
       # already resolves there, never to the host root.
@@ -165,6 +226,163 @@ module Chats
       @conversation = find_conversation
     end
 
+    def time_from_ms(value)
+      Time.zone.at(0, value.to_i, :millisecond)
+    end
+
+    def time_from_us(value)
+      Time.zone.at(0, value.to_i, :microsecond)
+    end
+
+    # What to append and what to replace: on the two microsecond cursors,
+    # or on the one millisecond cursor of bubbles ejected before them.
+    def catch_up_on(scope)
+      if params[:changed].present?
+        created_at, created_seen = cursor(:after)
+        updated_at, updated_seen = cursor(:changed)
+        [scope.created_after(created_at, seen: created_seen),
+         scope.created_through(created_at, seen: created_seen).updated_after(updated_at, seen: updated_seen)]
+      else
+        since = time_from_ms(params[:since])
+        [scope.created_since(since), scope.updated_since(since)]
+      end
+    end
+
+    # The moment and the ids seen with it, from `<name>=µs` and `<name>_ids=1,2`.
+    def cursor(name)
+      [time_from_us(params[name]), params[:"#{name}_ids"].to_s.split(",")]
+    end
+
+    def cursors_over_limit?
+      return true if params[:full].present?
+
+      %i[after_ids changed_ids].any? do |name|
+        ids = params[name].to_s.split(",")
+        ids.size > CURSOR_IDS_LIMIT || ids.any? { |id| id.size > CURSOR_ID_LENGTH }
+      end
+    end
+
+    # Where the client stands once it has rendered this answer: what it was
+    # sent is now known to be on screen, so the cursors move to it. Sent
+    # back with the answer (the chats_caught_up action), because only an
+    # answer that arrived may move them.
+    def caught_up_cursors
+      after = cursor(:after).first
+      changed_at, changed_seen = cursor(:changed)
+      sent = @new_messages + @updated_messages.to_a
+      after = [after, *@new_messages.map(&:created_at)].max
+
+      newest = sent.map(&:updated_at).max
+      changed_seen = [] if newest && newest > changed_at
+      changed_at = [changed_at, newest].compact.max
+      changed_seen |= sent.select { |message| message.updated_at == changed_at }.map { |message| message.id.to_s }
+
+      cursors_tag(after, changed_at, changed_seen)
+    end
+
+    def cursors_tag(after, changed_at, changed_seen)
+      helpers.turbo_stream_action_tag(
+        :chats_caught_up,
+        target: helpers.dom_id(@conversation, :messages),
+        "data-after": microseconds(after), "data-changed": microseconds(changed_at),
+        "data-changed-ids": changed_seen.join(","),
+        # Which render of the thread asked: an answer for an earlier one is
+        # ignored (see the thread controller's caughtUp).
+        "data-render": params[:render].to_s.first(CURSOR_ID_LENGTH).presence
+      )
+    end
+
+    def microseconds(time)
+      (time.to_i * 1_000_000) + time.usec
+    end
+
+    # The history at its latest page, or, for a thread view ejected before
+    # the history had its id (no `history=1`), the page refresh it always
+    # got. `request_id: nil`: Turbo skips a refresh tagged with a request of
+    # its own, and this one answers the client's own catch-up.
+    def render_from_scratch
+      return render_latest_history if params[:history].present?
+
+      render turbo_stream: turbo_stream.refresh(request_id: nil)
+    end
+
+    # The conversation's messages with everything a bubble renders.
+    def rendered_messages
+      scope = @conversation.messages.includes(:sender, :reactions)
+      scope.respond_to?(:with_attached_files) ? scope.with_attached_files : scope
+    end
+
+    # The newest page of +scope+, oldest first, and whether older pages
+    # exist. Fetched newest-first and reversed; one extra record peeks.
+    def latest_page_of(scope)
+      page = scope.recent_first.limit(Chats.config.messages_per_page + 1).to_a
+      [page.first(Chats.config.messages_per_page).reverse, page.size > Chats.config.messages_per_page]
+    end
+
+    # Where the «new messages» line goes: the oldest unread bubble on the
+    # page; when the backlog runs deeper than one page, the top of the page
+    # (the scroll-up frame chain holds the rest). Nil when nothing is unread.
+    def first_unread_id(participant, messages)
+      return unless participant&.unread?
+
+      participant.unread_messages.where(id: messages.map(&:id)).oldest_first.pick(:id) || messages.first&.id
+    end
+
+    # The thread's history at its latest page, for a catch-up more than a
+    # page behind: the same messages, frame chain and «new messages» line
+    # the thread opens with (chats/conversations/_history).
+    #
+    # A complete render, so it carries its own cursors: the newest creation
+    # and the newest change on the page.
+    def render_latest_history
+      messages, more = latest_page_of(rendered_messages)
+      participant = @conversation.participant_for(chats_current_messager)
+      newest_change = messages.map(&:updated_at).max || Time.zone.at(0)
+      history = turbo_stream.update(
+        helpers.dom_id(@conversation, :history),
+        partial: "chats/conversations/history",
+        locals: { conversation: @conversation, messages: messages, more: more,
+                  first_unread_id: first_unread_id(participant, messages),
+                  counterpart: chats_counterpart, window: false }
+      )
+      cursors = cursors_tag(messages.map(&:created_at).max || Time.zone.at(0), newest_change,
+                            messages.select { |message| message.updated_at == newest_change }.map { |m| m.id.to_s })
+
+      render turbo_stream: helpers.safe_join([history, cursors])
+    end
+
+    # Under `deletion: :hard` a deleted message leaves nothing to replace:
+    # the catch-up names every message from the client's oldest bubble on
+    # that still exists, and the client removes the bubbles not named.
+    # `until` sits PRESENT_MARGIN before the list is read: a message whose
+    # insert had not committed yet is missing from the list but may already
+    # have reached the client live — it must not be taken for a deleted one.
+    def present_messages
+      margin = Time.current - PRESENT_MARGIN
+      ids = @conversation.messages.where(created_at: time_from_us(params[:from])..).pluck(:id)
+
+      { ids: ids.map { |id| helpers.dom_id(Chats::Message.new(id: id)) },
+        until: (margin.to_i * 1_000_000) + margin.usec }
+    end
+
+    # A dock window asks for its thread from inside its own turbo frame. A
+    # plain visit to the same URL (no frame) still gets the page.
+    def dock_window?
+      params[:window].present? && turbo_frame_request?
+    end
+
+    # Turbo 8 prefetches a link when the pointer rests on it, and a pointer
+    # resting on an inbox row is not somebody reading the thread. The visit
+    # itself, if it happens, reads.
+    # https://turbo.hotwired.dev/handbook/drive#prefetching-links-on-hover
+    def prefetch?
+      request.headers["X-Sec-Purpose"] == "prefetch" || request.headers["Sec-Purpose"]&.include?("prefetch")
+    end
+
+    def dock_recent
+      Integer(params[:recent], exception: false)&.clamp(1, DOCK_RECENT_LIMIT) || 10
+    end
+
     def locate_signed!(sgid, purpose:)
       GlobalID::Locator.locate_signed(sgid, for: purpose) || raise(ActiveRecord::RecordNotFound)
     end

data/app/helpers/chats/engine_helper.rb

@@ -15,6 +15,7 @@ module Chats
       composer_actions
       locked_composer
       message_meta
+      dock_panel_footer
     ].freeze
 
     # The "message this person" affordance for host pages — a listing, a
@@ -24,18 +25,24 @@ module Chats
     #
     #   <%= chat_button_to @driver, about: @ride, label: "Chat with driver" %>
     #
+    # `dock: true` opens the conversation in a floating window of the
+    # messaging dock (`chats_dock`) instead of navigating to it. It belongs
+    # with `chats_dock` on the same page: without the dock the button's Turbo
+    # Stream has nowhere to land and nothing happens.
+    #
     # The recipient/subject travel as SIGNED GlobalIDs (purpose-scoped,
     # minted here, verified in Chats::ConversationsController#create), so the
     # endpoint never trusts raw polymorphic params. `expires_in: nil` because
     # these buttons sit on long-lived pages — the default 1-month sgid expiry
     # would quietly break stale tabs.
-    def chat_button_to(other, about: nil, label: nil, **html_options)
+    def chat_button_to(other, about: nil, label: nil, dock: false, **html_options)
       viewer = chats_viewer
       return if viewer.nil? || other.nil? || viewer == other
       return unless Chats.can_message?(viewer, other)
 
       params = { recipient_sgid: other.to_sgid(expires_in: nil, for: :chats_recipient).to_s }
       params[:subject_sgid] = about.to_sgid(expires_in: nil, for: :chats_subject).to_s if about
+      params[:dock] = 1 if dock
 
       button_to(
         label || I18n.t("chats.buttons.chat"),
@@ -50,13 +57,97 @@ module Chats
     # tab docks). Subscribes to the messager's badge stream so it updates in
     # real time without refreshing the page it sits on (see
     # Chats::Broadcasts for why badges get their own stream).
+    #
+    # The viewer's own badge also catches up on updates its stream missed
+    # (the chats--unread-badge controller asks GET /badge on a reconnect, on
+    # a return to a hidden page, on a restored page). Its wrapper is
+    # `display: contents` in chats.css, so it changes no layout.
     def chats_unread_badge(messager = chats_viewer)
       return if messager.nil?
 
-      safe_join([
-                  turbo_stream_from(messager, :chats_badge),
-                  render(partial: "chats/shared/unread_badge", locals: { count: messager.unread_chats_count })
-                ])
+      badge = safe_join([
+                          turbo_stream_from(messager, :chats_badge),
+                          render(partial: "chats/shared/unread_badge", locals: { count: messager.unread_chats_count })
+                        ])
+      return badge unless messager == chats_viewer
+
+      tag.span(badge, class: "chats-unread-badge-live",
+                      data: { controller: "chats--unread-badge",
+                              "chats--unread-badge-url-value": chats_routes.badge_conversations_path })
+    end
+
+    # The messaging dock, LinkedIn / Steam style: a bar in the bottom-right
+    # corner with the unread badge, a panel of recent conversations, and
+    # floating conversation windows. One line in the host's layout:
+    #
+    #   <%= chats_dock %>
+    #
+    # Renders nothing for a signed-out visitor, and nothing on the engine's
+    # own pages (the inbox, a thread): those already ARE the messaging UI,
+    # and a window there would duplicate the thread's DOM ids the live
+    # streams address. The dock is permanent across Turbo visits, so the
+    # server can't take it away on the next page: it also hides ITSELF on
+    # any page carrying `data-chats-dock-hide` (the engine's pages do; put
+    # it on your own messaging pages). `everywhere: true` renders it on the
+    # engine's pages and ignores data-chats-dock-hide (it still never opens
+    # a window for a conversation the page itself shows).
+    #
+    #   windows:   how many windows may be open at once (3, and never more
+    #              than fit beside the panel: 2 at 1280px, 1 at 768px)
+    #   recent:    how many conversations the panel lists (10)
+    #   launcher:  false drops the phone's floating button, for a host that
+    #              opens the sheet from its own nav (see chats_dock_toggle)
+    def chats_dock(windows: 3, recent: 10, launcher: true, everywhere: false)
+      viewer = chats_viewer
+      return if viewer.nil?
+      return if chats_engine_page? && !everywhere
+
+      render(partial: "chats/dock/dock",
+             locals: { viewer: viewer, windows: windows, recent: recent, launcher: launcher, everywhere: everywhere })
+    end
+
+    # The data that makes ANY link to a conversation — a recent-list row, a
+    # host's own link — open that conversation's dock window instead of
+    # navigating, when a dock is on the page. The link stays a real link: a
+    # modified click, a page without the dock, or no JavaScript navigates.
+    #
+    #   <%= link_to "Chat", chats.conversation_path(c), data: chats_dock_opener(c) %>
+    def chats_dock_opener(conversation)
+      { chats_dock_conversation_id: conversation.id }
+    end
+
+    # The data that makes a host's own Messages link open the dock's panel
+    # (the full-screen sheet on a phone) instead of navigating, when a dock
+    # is on the page. Pair it with `chats_dock(launcher: false)` to replace
+    # the phone's floating button with your nav's. Without the dock, or
+    # without JavaScript, the link goes where its href says.
+    #
+    #   <%= link_to "Messages", chats.conversations_path, data: chats_dock_toggle %>
+    def chats_dock_toggle
+      { chats_dock_toggle: true }
+    end
+
+    # The CLDR plural categories JavaScript's Intl.PluralRules answers with.
+    PLURAL_CATEGORIES = %i[zero one two few many other].freeze
+
+    # Every plural form of +key+ the current locale provides, for client-side
+    # pluralization ({ one: "…", few: "…", other: "…" }). The gem ships
+    # one/other; a host adds the forms its languages need (Polish few/many,
+    # Arabic zero/two…) in its own locale files. Empty when the key is
+    # missing, never a "translation missing" string.
+    def chats_plural_forms(key)
+      forms = I18n.t(key, default: {})
+      forms.is_a?(Hash) ? forms.slice(*PLURAL_CATEGORIES) : {}
+    end
+
+    # Whether +viewer+ muted +conversation+, read from the preloaded seats
+    # (the inbox loads them), so a row costs no query for it.
+    def chats_muted?(conversation, viewer)
+      return false if viewer.nil?
+
+      conversation.participants.any? do |seat|
+        seat.muted? && seat.messager_type == viewer.class.polymorphic_name && seat.messager_id == viewer.id
+      end
     end
 
     # An avatar for any messager: whatever `config.messager_avatar` returns
@@ -148,7 +239,7 @@ module Chats
     #   app/views/chats/slots/_inbox_top.html.erb
     #
     # The slots: inbox_top, inbox_empty, conversation_header_actions,
-    # composer_actions, locked_composer, message_meta.
+    # composer_actions, locked_composer, message_meta, dock_panel_footer.
     def chats_slot(name, **locals)
       return unless chats_slot?(name)
 
@@ -275,6 +366,11 @@ module Chats
       respond_to?(method_name) ? send(method_name) : nil
     end
 
+    # Whether this view is one of the engine's own screens.
+    def chats_engine_page?
+      respond_to?(:controller) && controller.is_a?(Chats::ApplicationController)
+    end
+
     # Active Storage routes are drawn on the host app, not on this isolated
     # engine. A bare `image_tag variant` is fine in normal host views, but
     # inside engine views it asks the engine route set to polymorphically

data/app/javascript/chats/composer_controller.js

@@ -76,8 +76,11 @@ export default class extends Controller {
   // are disabled while editing (edits are body-only by design).
 
   beginEdit(event) {
-    const { id, body } = event.detail || {}
+    const { id, body, thread } = event.detail || {}
     if (!id || !this.hasInputTarget) return
+    // Several threads can share a page (the dock's windows): only the
+    // composer of the thread the message lives in edits it.
+    if (thread && !thread.contains(this.element)) return
 
     this.createAction ||= this.element.action
     this.element.action = `${this.createAction}/${id}`
@@ -112,6 +115,16 @@ export default class extends Controller {
     this.inputTarget.setSelectionRange(this.inputTarget.value.length, this.inputTarget.value.length)
   }
 
+  // Escape while editing cancels the edit, and only that: the dock (if the
+  // composer is in one of its windows) sees the event handled and leaves
+  // the window alone.
+  escape(event) {
+    if (!this.editing) return
+
+    event.preventDefault()
+    this.cancelEdit()
+  }
+
   cancelEdit(event) {
     event?.preventDefault()
     this.exitEdit()