chats 0.1.1

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

@@ -0,0 +1,28 @@
+<%# One inbox row. Rendered per-viewer (this page only updates via full
+    refreshes, never shared broadcasts, so viewer-specific state is fine here —
+    unlike message bubbles, which must stay viewer-agnostic). %>
+<li class="chats-row <%= "chats-row--unread" if unread_count.positive? %>">
+  <%= link_to conversation_path(conversation), class: "chats-row__link" do %>
+    <%= chats_conversation_avatar(conversation, viewer) %>
+
+    <span class="chats-row__body">
+      <span class="chats-row__top">
+        <span class="chats-row__title"><%= conversation.title_for(viewer) %></span>
+        <time class="chats-row__time" datetime="<%= conversation.last_message_at&.iso8601 %>">
+          <%= chats_timestamp(conversation.last_message_at) %>
+        </time>
+      </span>
+
+      <% if conversation.subject_label %>
+        <span class="chats-row__subject"><%= conversation.subject_label %></span>
+      <% end %>
+
+      <span class="chats-row__bottom">
+        <span class="chats-row__preview"><%= chats_preview_for(conversation, viewer) %></span>
+        <% if unread_count.positive? %>
+          <span class="chats-badge"><%= unread_count > 99 ? "99+" : unread_count %></span>
+        <% end %>
+      </span>
+    </span>
+  <% end %>
+</li>

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

@@ -0,0 +1,16 @@
+<%# An OLDER page of messages, served into the pagination frame chain.
+    The wrapping frame id must equal the requesting frame's id (Turbo matches
+    by id), which both sides derive from the same anchor message — the
+    `before` param. Inside: the next lazy frame (when more pages exist),
+    then this page's messages, which Turbo splices in place of the loader. %>
+<%= turbo_frame_tag "chats_page_#{params[:before]}" do %>
+  <% if more && messages.any? %>
+    <%= turbo_frame_tag "chats_page_#{messages.first.id}",
+          src: conversation_path(conversation, before: messages.first.id),
+          loading: :lazy do %>
+      <div class="chats-loader"><%= t("chats.thread.loading") %></div>
+    <% end %>
+  <% end %>
+
+  <%= render partial: "chats/messages/message", collection: messages, as: :message %>
+<% end %>

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

@@ -0,0 +1,11 @@
+<%# Viewer-agnostic read-state payload: every active participant's read
+    horizon, keyed by messager key. Broadcast-replaced whenever anyone reads
+    (Chats::Broadcasts.read_state); the chats--thread controller derives the
+    per-viewer "Seen" indicator from it client-side. %>
+<div id="<%= dom_id(conversation, :read_state) %>"
+     data-chats--thread-target="readState"
+     data-horizons="<%= conversation.participants.active.includes(:messager).each_with_object({}) { |participant, horizons|
+       next if participant.messager.nil?
+       horizons[Chats.messager_key(participant.messager)] = participant.last_read_at&.iso8601
+     }.to_json %>"
+     hidden></div>

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

@@ -0,0 +1,54 @@
+<%# The inbox. Subscribed to the viewer's inbox stream: new activity anywhere
+    triggers a Turbo 8 page refresh (morphing, scroll-preserving), which
+    re-renders this page per-viewer — see Chats::Broadcasts for why refreshes
+    beat surgical row patches here. %>
+<%= chats_styles %>
+<%= turbo_stream_from chats_current_messager, :chats_inbox %>
+
+<div class="chats chats-inbox">
+  <header class="chats-inbox__header">
+    <h1 class="chats-inbox__title"><%= t("chats.inbox.title") %></h1>
+  </header>
+
+  <% if Chats.config.search %>
+    <%= form_with url: conversations_path,
+          method: :get,
+          class: "chats-search",
+          role: "search",
+          data: {
+            controller: "chats--debounced-submit",
+            action: "input->chats--debounced-submit#queue search->chats--debounced-submit#queue",
+            "chats--debounced-submit-delay-value": 250,
+            turbo_frame: "chats_inbox_results"
+          } do %>
+      <%= search_field_tag :q, params[:q],
+            placeholder: t("chats.inbox.search_placeholder"),
+            class: "chats-search__input",
+            autocomplete: "off" %>
+    <% end %>
+  <% end %>
+
+  <%= turbo_frame_tag "chats_inbox_results", target: "_top" do %>
+    <% if @conversations.any? %>
+      <ul class="chats-inbox__list">
+        <% @conversations.each do |conversation| %>
+          <%= render "chats/conversations/conversation_row",
+                conversation: conversation,
+                viewer: chats_current_messager,
+                unread_count: @unread_counts.fetch(conversation.id, 0) %>
+        <% end %>
+      </ul>
+    <% elsif params[:q].present? %>
+      <div class="chats-empty">
+        <p class="chats-empty__title"><%= t("chats.inbox.no_results_title") %></p>
+        <p class="chats-empty__hint"><%= t("chats.inbox.no_results_hint", query: params[:q]) %></p>
+      </div>
+    <% else %>
+      <div class="chats-empty">
+        <span class="chats-empty__icon" aria-hidden="true">💬</span>
+        <p class="chats-empty__title"><%= t("chats.inbox.empty_title") %></p>
+        <p class="chats-empty__hint"><%= t("chats.inbox.empty_hint") %></p>
+      </div>
+    <% end %>
+  <% end %>
+</div>

data/app/views/chats/conversations/refresh.turbo_stream.erb

@@ -0,0 +1,13 @@
+<%# Stale-thread catch-up payload (ConversationsController#refresh):
+    append what arrived while the client slept, replace what changed.
+    Appends are idempotent by dom_id, so a message that raced in through
+    the live stream during the fetch can't duplicate. %>
+<%= turbo_stream.append dom_id(@conversation, :messages) do %>
+  <%= render partial: "chats/messages/message", collection: @new_messages, as: :message %>
+<% end if @new_messages.any? %>
+
+<% @updated_messages.each do |message| %>
+  <%= turbo_stream.replace dom_id(message),
+        partial: "chats/messages/message",
+        locals: { message: message } %>
+<% end %>

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

@@ -0,0 +1,137 @@
+<%# The thread. One conversation stream powers everything live here:
+    message append/replace/remove, the read-state payload, and typing pings.
+    Bubbles arrive VIEWER-AGNOSTIC from shared broadcasts; the chats--thread
+    Stimulus controller aligns own-vs-other by comparing each bubble's
+    sender key against its `me` value (that's what makes one broadcast render
+    work for every subscriber). %>
+<%= chats_styles %>
+
+<%= tag.div class: "chats chats-thread", data: {
+      controller: "chats--thread",
+      "chats--thread-me-value": Chats.messager_key(chats_current_messager),
+      "chats--thread-read-url-value": read_conversation_path(@conversation),
+      "chats--thread-sent-label-value": t("chats.thread.sent"),
+      "chats--thread-seen-label-value": Chats.config.read_receipts ? t("chats.thread.seen") : "",
+      "chats--thread-today-label-value": t("chats.thread.today"),
+      "chats--thread-yesterday-label-value": t("chats.thread.yesterday"),
+      "chats--thread-typing-suffix-value": t("chats.thread.typing_suffix"),
+      "chats--thread-group-value": @conversation.group?,
+      "chats--thread-refresh-url-value": refresh_conversation_path(@conversation),
+      "chats--thread-thread-url-value": conversation_path(@conversation),
+      "chats--thread-copied-label-value": t("chats.message.copied"),
+      action: "pointerdown->chats--thread#pressStart pointermove->chats--thread#pressMove " \
+              "pointerup->chats--thread#pressEnd pointercancel->chats--thread#pressCancel " \
+              "contextmenu->chats--thread#contextMenu"
+    } do %>
+
+  <%= turbo_stream_from @conversation %>
+
+  <header class="chats-thread__header">
+    <%= link_to root_path, class: "chats-thread__back", "aria-label": t("chats.thread.back") do %>
+      <span aria-hidden="true">‹</span>
+    <% end %>
+
+    <%= chats_conversation_avatar(@conversation, chats_current_messager) %>
+
+    <div class="chats-thread__identity">
+      <h1 class="chats-thread__title"><%= @conversation.title_for(chats_current_messager) %></h1>
+      <% if @conversation.subject_label %>
+        <p class="chats-thread__subject"><%= @conversation.subject_label %></p>
+      <% end %>
+    </div>
+
+    <details class="chats-menu">
+      <summary class="chats-menu__trigger" aria-label="<%= t("chats.thread.options") %>">⋯</summary>
+      <div class="chats-menu__panel">
+        <% if @participant&.muted? %>
+          <%= button_to t("chats.thread.unmute"), unmute_conversation_path(@conversation), method: :post, class: "chats-menu__item" %>
+        <% else %>
+          <%= button_to t("chats.thread.mute"), mute_conversation_path(@conversation), method: :post, class: "chats-menu__item" %>
+        <% end %>
+        <% if @conversation.group? %>
+          <%= button_to t("chats.thread.leave"), leave_conversation_path(@conversation), method: :post, class: "chats-menu__item chats-menu__item--danger" %>
+        <% end %>
+      </div>
+    </details>
+  </header>
+
+  <div class="chats-thread__scroll" data-chats--thread-target="scroller">
+    <% if @more_messages && @messages.any? %>
+      <%# Lazy frame chain for infinite scroll-up: when this frame becomes
+          visible, Turbo fetches the previous keyset page (?before=oldest id),
+          whose response contains a frame with this SAME id — older messages
+          plus, recursively, the next frame. See ConversationsController#show. %>
+      <%= turbo_frame_tag "chats_page_#{@messages.first.id}",
+            src: conversation_path(@conversation, before: @messages.first.id),
+            loading: :lazy do %>
+        <div class="chats-loader"><%= t("chats.thread.loading") %></div>
+      <% end %>
+    <% end %>
+
+    <div id="<%= dom_id(@conversation, :messages) %>" class="chats-thread__messages">
+      <%# Explicit loop (not a collection render) so the «new messages»
+          divider can sit BEFORE the first unread bubble (WhatsApp's "the
+          catch-up starts here" line). Server-rendered on the initial page
+          only; it scrolls away naturally as the thread lives on. %>
+      <% @messages.each do |message| %>
+        <% if message.id == @first_unread_id %>
+          <div class="chats-thread__unread-line" role="separator">
+            <span><%= t("chats.thread.new_messages") %></span>
+          </div>
+        <% end %>
+        <%= render "chats/messages/message", message: message %>
+      <% end %>
+    </div>
+
+    <%= render "chats/conversations/read_state", conversation: @conversation %>
+
+    <div id="<%= dom_id(@conversation, :typing) %>"
+         class="chats-typing"
+         data-chats--thread-target="typing"
+         hidden></div>
+  </div>
+
+  <%# Long-press popup (Telegram-style): the backdrop blurs the thread, the
+      pressed bubble's clone morphs to the center, the reactions pill sits
+      above it and the contextual menu below. Slots are filled by cloning
+      the bubble's <template data-chats-message-menu>. %>
+  <div class="chats-popup"
+       role="dialog"
+       aria-modal="true"
+       data-chats--thread-target="popup"
+       hidden>
+    <div class="chats-popup__backdrop" data-action="click->chats--thread#closePopup"></div>
+    <div class="chats-popup__stack">
+      <div class="chats-popup__slot chats-popup__slot--reactions"
+           data-chats--thread-target="popupReactions"
+           data-action="click->chats--thread#popupMenuClicked"></div>
+      <div class="chats-popup__slot chats-popup__slot--bubble" data-chats--thread-target="popupBubble"></div>
+      <div class="chats-popup__slot chats-popup__slot--menu"
+           data-chats--thread-target="popupMenu"
+           data-action="click->chats--thread#popupMenuClicked"></div>
+    </div>
+  </div>
+
+  <div class="chats-attachment-preview"
+       role="dialog"
+       aria-modal="true"
+       tabindex="-1"
+       data-chats--thread-target="attachmentDialog"
+       data-action="keydown.esc->chats--thread#closeAttachment"
+       hidden>
+    <div class="chats-attachment-preview__surface"
+         data-action="click->chats--thread#closeAttachmentFromBackdrop">
+      <button type="button"
+              class="chats-attachment-preview__close"
+              aria-label="<%= t("chats.message.close_attachment") %>"
+              data-action="chats--thread#closeAttachment">×</button>
+      <figure class="chats-attachment-preview__figure">
+        <img class="chats-attachment-preview__image"
+             alt=""
+             data-chats--thread-target="attachmentImage">
+      </figure>
+    </div>
+  </div>
+
+  <%= render "chats/messages/composer", conversation: @conversation %>
+<% end %>

data/app/views/chats/messages/_composer.html.erb

@@ -0,0 +1,67 @@
+<%# The composer. Submits as a Turbo Stream (the sender's bubble appends from
+    the response — instant, no cable round-trip needed); the chats--composer
+    controller adds autosize, desktop Enter-to-send, throttled typing pings,
+    and reset-on-success. Plain form POST still works with JS disabled. %>
+<%= form_with model: Chats::Message.new,
+      url: conversation_messages_path(conversation),
+      class: "chats-composer",
+      data: {
+        controller: "chats--composer",
+        "chats--composer-typing-url-value": (typing_conversation_path(conversation) if Chats.config.typing_indicators),
+        action: "turbo:submit-end->chats--composer#submitted chats:edit-message@window->chats--composer#beginEdit"
+      } do |form| %>
+
+<div id="<%= dom_id(conversation, :composer_errors) %>" class="chats-composer__errors"></div>
+
+<%# The edit cue (Telegram's flow): long-press → Editar loads the message
+    into this same form; this quote-style bar (left border, bold label,
+    the original trimmed to one line) is the signal that send = save.
+    The ✕ cancels back to compose mode. %>
+<div class="chats-composer__edit" data-chats--composer-target="editBar" hidden>
+  <div class="chats-composer__edit-quote">
+    <span class="chats-composer__edit-label"><%= t("chats.composer.editing") %></span>
+    <span class="chats-composer__edit-preview" data-chats--composer-target="editPreview"></span>
+  </div>
+  <button type="button"
+          class="chats-composer__edit-cancel"
+          aria-label="<%= t("chats.composer.cancel_edit") %>"
+          data-action="chats--composer#cancelEdit">×</button>
+</div>
+
+  <%# Selected-attachment previews: thumbnails with per-file remove, rendered
+      client-side from the picker selection (object URLs — nothing uploads
+      until send). This is THE feedback that files are about to go out; a
+      counter chip alone reads as noise. %>
+  <% if Chats.config.attachments %>
+    <div class="chats-composer__previews" data-chats--composer-target="previews" hidden></div>
+  <% end %>
+
+  <div class="chats-composer__bar">
+    <% if Chats.config.attachments %>
+      <label class="chats-composer__attach" aria-label="<%= t("chats.composer.attach") %>">
+        <%= form.file_field :files, multiple: true, hidden: true,
+              accept: (Chats.config.attachments == :images ? "image/*" : nil),
+              data: { "chats--composer-target": "files", action: "change->chats--composer#filesChanged" } %>
+        <span aria-hidden="true">📎</span>
+        <span class="chats-composer__file-count" data-chats--composer-target="fileCount" hidden></span>
+      </label>
+    <% end %>
+
+    <%= form.text_area :body,
+          rows: 1,
+          placeholder: t("chats.composer.placeholder"),
+          class: "chats-composer__input",
+          autocomplete: "off",
+          data: {
+            "chats--composer-target": "input",
+            action: "input->chats--composer#typed keydown.enter->chats--composer#enterSend"
+          } %>
+
+    <%# pointerdown/mousedown keepFocus: keeps the textarea focused (and the
+        mobile keyboard up) through the send tap — see composer controller. %>
+    <%= form.button type: :submit, class: "chats-composer__send", "aria-label": t("chats.composer.send"),
+          data: { action: "pointerdown->chats--composer#keepFocus mousedown->chats--composer#keepFocus" } do %>
+      <span aria-hidden="true">➤</span>
+    <% end %>
+  </div>
+<% end %>

data/app/views/chats/messages/_message.html.erb

@@ -0,0 +1,158 @@
+<%# One message bubble. CRITICAL CONSTRAINT: this partial renders ONCE per
+    broadcast and is delivered to EVERY subscriber, so nothing here may depend
+    on the viewer. Own-vs-other alignment, receipt state, and showing the
+    own-message actions menu are all decided CLIENT-SIDE by the chats--thread
+    controller comparing data-sender-key against its me-value (and CSS rules
+    on .chats-message--own). Server-side authorization still gates every
+    action — hiding is cosmetic, never security.
+
+    The wrapper id (dom_id) also makes Turbo Stream appends idempotent: when
+    the sender gets both the form response AND the broadcast, Turbo removes
+    the existing element with the same id before appending — no duplicates.
+    https://turbo.hotwired.dev/reference/streams %>
+<div id="<%= dom_id(message) %>"
+     class="chats-message<%= " chats-message--system" if message.system? %><%= " chats-message--deleted" if message.deleted? %>"
+     data-chats--thread-target="message"
+     data-sender-key="<%= message.sender_key %>"
+     data-timestamp="<%= message.created_at.iso8601 %>"
+     <%# updated-at-ms: the thread controller tracks the max across bubbles as
+         its `?since=` cursor for the stale-thread refresh — updated_at (not
+         created_at) so edits/tombstones that happened while asleep are caught
+         too. `.ceil` biases the cursor PAST this row's sub-millisecond tail,
+         so the strictly-greater server query can't re-fetch it. %>
+     data-updated-at-ms="<%= (message.updated_at.to_f * 1000).ceil %>">
+
+  <% if message.system? %>
+    <div class="chats-message__system"><%= message.body %></div>
+  <% else %>
+    <div class="chats-message__content">
+      <% if message.conversation.group? && message.sender %>
+        <span class="chats-message__sender"><%= Chats.display_name_for(message.sender) %></span>
+      <% end %>
+
+      <div class="chats-message__bubble-row">
+        <%= chats_messager_avatar(message.sender, css_class: "chats-avatar chats-message__avatar") %>
+
+        <div class="chats-message__bubble">
+          <% if message.deleted? %>
+            <em class="chats-message__tombstone"><%= t("chats.message.deleted") %></em>
+          <% else %>
+            <% if message.body.present? %>
+              <%# Plain escaped text + white-space: pre-wrap (chats.css), NOT
+                  simple_format: chat semantics are literal — every newline the
+                  sender typed renders, including consecutive blank lines, which
+                  simple_format collapses into a single paragraph break. ERB
+                  escaping keeps user content from ever rendering as HTML. The
+                  single marked node is the copy/edit contract. %>
+              <div class="chats-message__text" data-chats-message-body><%= message.body %></div>
+            <% end %>
+
+            <% if message.attachments? %>
+              <div class="chats-message__attachments">
+                <%# main_app.url_for, NOT bare url_for: Active Storage's routes
+                    live in the MAIN app — inside this isolated engine (and in
+                    the broadcast renderer) bare url_for would look for
+                    attachment_path on the ENGINE's routes and blow up. %>
+                <% message.files.each do |file| %>
+                  <% if file.image? %>
+                    <%= link_to main_app.url_for(file),
+                          class: "chats-message__image-link",
+                          data: {
+                            action: "chats--thread#openAttachment"
+                          } do %>
+                      <%# Thumbnails only when the host can actually transform:
+                          `variable?` checks the content type, the ImageProcessing
+                          check that the variant-processing gem is installed —
+                          otherwise serving the variant URL would 500 later. %>
+                      <% representable = file.variable? && defined?(ImageProcessing) %>
+                      <%= image_tag main_app.url_for(representable ? file.variant(resize_to_limit: [480, 480]) : file),
+                            class: "chats-message__image", loading: "lazy", alt: file.filename.to_s %>
+                    <% end %>
+                  <% else %>
+                    <%= link_to "📄 #{file.filename}", main_app.url_for(file), target: "_blank", rel: "noopener", class: "chats-message__file" %>
+                  <% end %>
+                <% end %>
+              </div>
+            <% end %>
+          <% end %>
+
+          <span class="chats-message__meta">
+            <% if message.edited? && !message.deleted? %>
+              <span class="chats-message__edited"><%= t("chats.message.edited") %></span>
+            <% end %>
+            <time datetime="<%= message.created_at.iso8601 %>"><%= message.created_at.in_time_zone.strftime("%H:%M") %></time>
+            <% if Chats.config.read_receipts %>
+              <span class="chats-message__receipt"
+                    data-chats-message-receipt
+                    aria-hidden="true"
+                    hidden></span>
+              <span class="chats-visually-hidden"
+                    data-chats-message-receipt-label
+                    hidden></span>
+            <% end %>
+          </span>
+        </div>
+      </div>
+
+      <% unless message.deleted? %>
+        <% reactions = Chats.config.reactions ? Chats::Reaction.summary_for(message) : [] %>
+        <% if reactions.any? %>
+          <div class="chats-message__reactions">
+            <%# chats_routes (the mounted proxy), NOT bare engine helpers:
+                this partial is also rendered by Turbo broadcasts, which go
+                through the HOST's renderer where engine helpers don't exist
+                unqualified. See EngineHelper#chats_routes. %>
+            <% reactions.each do |emoji, count| %>
+              <%= button_to chats_routes.conversation_message_reactions_path(message.conversation, message),
+                    method: :post, params: { emoji: emoji },
+                    class: "chats-reaction", "aria-label": t("chats.message.toggle_reaction", emoji: emoji) do %>
+                <%= emoji %><% if count > 1 %><span class="chats-reaction__count"><%= count %></span><% end %>
+              <% end %>
+            <% end %>
+          </div>
+        <% end %>
+
+        <%# The long-press menu (Telegram-style). NOTHING actionable renders
+            inline anymore — everything lives in this inert <template>, which
+            the thread controller clones into the popup overlay on
+            long-press/right-click: the reactions pill lands above the
+            lifted bubble, this contextual menu below it. Items marked
+            data-chats-own-only are stripped from the clone for foreign
+            messages (cosmetic — the server still authorizes for real).
+            button_to forms keep working when cloned: the CSRF token is
+            baked in at render time. %>
+        <template data-chats-message-menu>
+          <% if Chats.config.reactions %>
+            <div class="chats-popup__reactions" role="group" aria-label="<%= t("chats.message.react") %>">
+              <% %w[👍 ❤️ 😂 😮 😢 🙏].each do |emoji| %>
+                <%= button_to emoji, chats_routes.conversation_message_reactions_path(message.conversation, message),
+                      method: :post, params: { emoji: emoji }, class: "chats-popup__reaction" %>
+              <% end %>
+            </div>
+          <% end %>
+
+          <div class="chats-popup__menu" role="menu">
+            <% if message.body.present? %>
+              <button type="button" class="chats-popup__item" role="menuitem" data-chats-action="copy">
+                <%= t("chats.message.copy") %>
+              </button>
+            <% end %>
+            <% if Chats.config.editing && message.body.present? %>
+              <button type="button" class="chats-popup__item" role="menuitem" data-chats-action="edit" data-chats-own-only>
+                <%= t("chats.message.edit") %>
+              </button>
+            <% end %>
+            <% if Chats.config.deletion %>
+              <%= button_to t("chats.message.delete"),
+                    chats_routes.conversation_message_path(message.conversation, message),
+                    method: :delete,
+                    class: "chats-popup__item chats-popup__item--danger",
+                    role: "menuitem",
+                    form: { data: { turbo_confirm: t("chats.message.delete_confirm"), chats_own_only: true } } %>
+            <% end %>
+          </div>
+        </template>
+      <% end %>
+    </div>
+  <% end %>
+</div>

data/app/views/chats/messages/create.turbo_stream.erb

@@ -0,0 +1,6 @@
+<%# Sender-side instant append (everyone else gets the broadcast; the sender
+    receives that too, where Turbo's same-id dedup turns it into a no-op). %>
+<%= turbo_stream.append dom_id(@conversation, :messages) do %>
+  <%= render "chats/messages/message", message: @message %>
+<% end %>
+<%= turbo_stream.update dom_id(@conversation, :composer_errors), "" %>

data/app/views/chats/messages/errors.turbo_stream.erb

@@ -0,0 +1,3 @@
+<%= turbo_stream.update dom_id(@conversation, :composer_errors) do %>
+  <p class="chats-composer__error"><%= @message.errors.full_messages.to_sentence %></p>
+<% end %>

data/app/views/chats/shared/_unread_badge.html.erb

@@ -0,0 +1,6 @@
+<%# The live unread badge (embed anywhere via the chats_unread_badge helper).
+    Fixed id: it's the target Chats::Broadcasts.update_badge_of replaces.
+    Always rendered (hidden at zero) so the broadcast has an element to update. %>
+<span id="chats_unread_badge"
+      class="chats-badge chats-badge--floating"
+      <%= "hidden" unless count.positive? %>><%= count > 99 ? "99+" : count %></span>

data/config/importmap.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+# Pinned under "controllers/chats/..." ON PURPOSE: the stock Rails Stimulus
+# setup (app/javascript/controllers/index.js) runs
+# `eagerLoadControllersFrom("controllers", application)`, which scans the
+# rendered importmap for ^controllers/.*_controller$ keys and registers each
+# one, deriving identifiers from paths — these become "chats--thread",
+# "chats--composer", etc. with ZERO host JavaScript changes. (stimulus-rails,
+# app/assets/javascripts/stimulus-loading.js, registerControllerFromPath.)
+#
+# Hosts can override either controller by pinning the same key themselves —
+# the engine's importmap is drawn FIRST (unshifted in Chats::Engine), and
+# importmap-rails resolves duplicate pins last-wins.
+pin "controllers/chats/thread_controller", to: "chats/thread_controller.js"
+pin "controllers/chats/composer_controller", to: "chats/composer_controller.js"
+pin "controllers/chats/debounced_submit_controller", to: "chats/debounced_submit_controller.js"

data/config/locales/en.yml

@@ -0,0 +1,87 @@
+en:
+  chats:
+    inbox:
+      title: "Messages"
+      search_placeholder: "Search conversations"
+      empty_title: "No conversations yet"
+      empty_hint: "When you start a conversation, it will show up here."
+      no_results_title: "No results"
+      no_results_hint: "Nothing matched “%{query}”."
+      no_messages: "No messages yet"
+      you_prefix: "You:"
+    thread:
+      back: "Back"
+      options: "Conversation options"
+      mute: "Mute"
+      unmute: "Unmute"
+      leave: "Leave group"
+      loading: "Loading…"
+      sent: "Sent"
+      seen: "Seen"
+      today: "Today"
+      yesterday: "Yesterday"
+      typing_suffix: "is typing…"
+      new_messages: "New messages"
+    conversation:
+      empty_title: "Conversation"
+    message:
+      deleted: "Message deleted"
+      edited: "edited"
+      copy: "Copy"
+      copied: "Copied!"
+      attachment: "Photo"
+      close_attachment: "Close photo"
+      edit: "Edit"
+      delete: "Delete"
+      delete_confirm: "Delete this message for everyone?"
+      cancel: "Cancel"
+      save: "Save"
+      react: "React"
+      toggle_reaction: "React with %{emoji}"
+    composer:
+      editing: "Edit message"
+      cancel_edit: "Cancel edit"
+      placeholder: "Write a message…"
+      send: "Send"
+      attach: "Attach images"
+    buttons:
+      chat: "Message"
+    flashes:
+      blocked: "You can't message this person."
+      not_allowed: "You can't start this conversation."
+      left: "You left “%{title}”."
+      muted: "Conversation muted."
+      unmuted: "Conversation unmuted."
+
+  activerecord:
+    errors:
+      models:
+        chats/conversation:
+          attributes:
+            kind:
+              groups_disabled: "group conversations are disabled"
+        chats/participant:
+          attributes:
+            base:
+              group_full: "this group is full (max %{count} members)"
+        chats/message:
+          attributes:
+            base:
+              blocked: "You can't message this person."
+            sender:
+              blank: "is required"
+              not_a_participant: "is not a participant of this conversation"
+            body:
+              blank: "can't be empty"
+              too_long: "is too long (maximum %{count} characters)"
+            files:
+              not_allowed: "attachments are disabled"
+              too_many: "too many attachments (maximum %{count})"
+              must_be_images: "only images are allowed"
+              too_big: "files must be smaller than %{count} MB"
+        chats/reaction:
+          attributes:
+            base:
+              reactions_disabled: "reactions are disabled"
+            reactor:
+              not_a_participant: "is not a participant of this conversation"