@convokitapp/vue-ui 0.7.0 → 0.9.0

package/CHANGELOG.md

@@ -1,5 +1,230 @@
 # Changelog
 
+## 0.9.0
+
+- Quoted replies. `useConversation` / `ConversationController` gain
+  `replyTarget` (the message the composer is quoting, as it stood when the
+  quote was started; null otherwise), `replyPreviews` (a read-only map from
+  `Message.replyToMessageId` to the resolved `ReplyPreview`, or the terminal
+  `'unavailable'`; a MISSING key is the distinct third state, "not resolved
+  yet"), `canResolveReplyPreviews` (adapter support), `startReply(messageId)`
+  (a no-op unless the row is rendered, confirmed, not known to be gone and the
+  viewer's role when known is not `READ`; any member may quote any row, own or
+  not; sends nothing, not even a typing update) and `cancelReply()`. Replying
+  and editing are mutually exclusive: `startReply` leaves edit mode and
+  `startEditing` drops the quote. `sendMessage` stamps `replyToMessageId` on
+  the optimistic row so the quoted block renders before the server
+  acknowledges the send, sends the key only when a quote is set (a plain send
+  stays byte-identical to 0.8.0) and clears the target only once the send was
+  accepted; a failed send keeps the draft and the quote. Deleting the quoted
+  message drops the target.
+- Batched preview resolution. After every page load, reconcile and live-insert
+  burst the store issues ONE `getReplyPreviews` call for the distinct quoted
+  parents the rendered rows point at and the loaded window cannot derive; a
+  parent that is on screen is derived locally (text cut at 500 characters,
+  `textTruncated` and `mediaCount` set) and costs no request, and a burst of
+  inserts is coalesced behind a short debounce whose handle is cleared with
+  the subscriptions. Previews are RE-READ, never copied: a `message_deleted`
+  event or a delete response for the id caches the terminal `'unavailable'`;
+  a row image, hydration or edit response for the id refreshes the entry from
+  the rendered row, or marks it stale when the parent is outside the window;
+  a reconnect (`SUBSCRIBED`) marks every non-terminal entry stale. An id a
+  RESOLVED call did not return is `'unavailable'` (the reference and the jump
+  affordance stay, the text becomes `Original message unavailable`) and is
+  never requested again. A REJECTED call writes no entry for any of its ids:
+  they stay unresolved, the failure surfaces through `error` without evicting
+  a row, and the next trigger asks again. A completed reconcile drops entries
+  no rendered row references, so the map stays bounded by the window.
+- Jump to message. `jumpToMessage(messageId)` highlights a rendered row
+  without a request; otherwise it REPLACES the window with a
+  `getMessageContext` window centred on the target and sets
+  `windowMode: 'jumped'`, with `hasOlderMessages` / `hasNewerMessages` from
+  the returned cursors. A jump is a window operation, never a re-open:
+  tombstones, the acknowledgement floor, this open's captured private state,
+  edit mode and the reply target all survive it, it arms no acknowledgement,
+  and the replacement installs exactly the rows the response carried (filtered
+  by tombstones only, with no pending or live-tail replay). A coded 404
+  `MESSAGE_NOT_FOUND` — the guaranteed answer for a quoted message that was
+  deleted — marks that preview `'unavailable'` instead of reporting an error,
+  and leaves the window untouched. Context pages are checked by their own
+  validator (room-scoped, distinct, non-pending, newest-first, within the
+  requested limit, and for a centred window the target exactly once).
+- Jumped windows. While `windowMode` is `jumped` the store acknowledges
+  nothing (the newest rendered row is not the newest row in the room), older
+  AND newer paging go through the window's own cursors (`loadNewerMessages()`
+  joins `loadOlderMessages()`), realtime inserts are recorded but not rendered
+  (ingestion still runs, so hydration, media completion, send confirmation and
+  tombstones keep working) and a queued reconcile re-reads the window with ONE
+  bounded request around its anchor instead of walking history from the live
+  tail — the tail reconcile is not dropped, it stays owed and flushes on the
+  return. `returnToLatest()` sets `live` BEFORE issuing the newest-page
+  request, so inserts arriving during it are folded in by the existing
+  precedence, then drains the deferred rows and issues the acknowledgement
+  they did not; a failed reload stays `jumped` with the window, the
+  affordance and the highlight intact. A newer page that reaches the tail runs
+  `returnToLatest()` rather than flipping in place. `sendMessage` returns to
+  the tail first (keeping the draft and the quote, and sending nothing when
+  that fails), and `jumpToMessage` is a no-op while a send is in flight.
+- Default rows. A `Reply to message` action joins `.ckui-message-actions` on
+  any confirmed row of a writer (never pending rows, never a `READ` role);
+  `canReplyToMessage` replaces that eligibility and `canEditMessage`
+  deliberately does not. A row with `replyToMessageId` renders
+  `.ckui-message-quote` above its text in three states: the resolved author
+  and truncated text (accessible name `Quoted message from <author>`),
+  `Original message unavailable`, and — while the preview is not resolved yet
+  — the reference alone (`Quoted message`), never the unavailable copy. The
+  block is a button that jumps whenever the view can. Rows without the new
+  callbacks render byte-identically to 0.8.0.
+- Highlight, scrolling and accessibility. The jumped-to row is centred with
+  `scrollIntoView({ block: 'center', behavior: 'instant' })`, focused with
+  `preventScroll` (only for an explicit jump, never for autoscroll, page loads
+  or live inserts) and tinted with the new `--ckui-highlight` theme token for
+  about two seconds; a user scroll clears the tint. One store-owned guard,
+  `jumpInFlight`, is set before the window is replaced and released on a short
+  timer: while it is set the list carries `aria-busy="true"` (omitted entirely
+  otherwise, never `aria-busy="false"`) and suspends stick-to-bottom, the
+  highlight clear and both pagination triggers. The custom-row slot wrapper
+  now carries `data-message-id`, so a replaced row is still a jump target; the
+  default row keeps carrying it on its `article`.
+- Composer. A cancellable `.ckui-composer__replying` strip (`role="status"`,
+  visible `Cancel`, accessible name `Cancel reply`, also Escape) renders where
+  the edit banner does and never touches the draft — replying, unlike editing,
+  does not replace the field. Edit mode wins when a host sets both.
+  `#composer` slots receive `replying` and `cancelReply` in Vue's flat shape,
+  beside `editing` / `cancelEdit`.
+- Controlled views. `ConversationView` gains `replyTarget`,
+  `onReplyToMessage`, `onCancelReply`, `canReplyToMessage`,
+  `replyPreviewByMessageId`, `onJumpToMessage`, `highlightedMessageId`,
+  `jumpInFlight`, `hasNewerMessages`, `isLoadingNewer`, `onLoadNewer` and
+  `onReturnToLatest` (and the `@reply-to-message`, `@cancel-reply`,
+  `@jump-to-message`, `@load-newer`, `@return-to-latest` events);
+  `MessageListView` gains all of those except `replyTarget`, `onCancelReply`
+  and `onReturnToLatest`, plus a `#loading-newer` slot. `onReturnToLatest` is
+  what renders the `Jump to latest` control, so the bound `Conversation`
+  passes it only while the window is jumped; a `#jump-to-latest` slot
+  (`JumpToLatestSlotProps`, carrying `returnToLatest`) replaces that control's
+  markup, and renders only where it does. `#message` slots gain the flat
+  `canReply`, `reply()`, `replyPreview` and `jumpToReplyTarget()` members.
+- Adapter. `ConvoKitUiClient.getReplyPreviews?(conversationId, messageIds)`
+  and `getMessageContext?(conversationId, options)` are optional and the
+  default adapter implements both; without them the jump affordance is hidden
+  and reply references render with no quoted text. Replying itself needs no
+  adapter member, so rows offer the action even on a 0.8-era adapter.
+- Mixed fleet. Against a 0.8 backend both new routes answer with an uncoded
+  404 (`HTTP_ERROR`), which is never read as "the message is gone": no preview
+  becomes `'unavailable'` and no window is replaced. After the first such
+  rejection the store turns `canResolveReplyPreviews` / `canJumpToMessage`
+  false for its life so the affordance disappears instead of failing
+  repeatedly; a coded `404 MESSAGE_NOT_FOUND` never trips that.
+- Requires `@convokitapp/sdk` 0.9.x and the corresponding backend deployment.
+- Mixed fleet, sending: a pre-0.9 backend parses only `text` and `media`, so it
+  DROPS an unknown `replyToMessageId` and stores the message with no reference.
+  The optimistic row shows the quote and the confirmed row replaces it without
+  one, so the quote visibly disappears on send. The message itself is delivered;
+  only the reference is lost. This is not detected — the send response is the
+  only signal, and acting on it would mean a second request or rewriting a row
+  that is already delivered.
+
+## 0.8.0
+
+- Edit and delete your own messages. `useConversation` /
+  `ConversationController` gain `editingMessage` (the row being edited, as
+  the user saw it when editing started; null otherwise), `canEditMessages` /
+  `canDeleteMessages` (adapter support, decided once at construction),
+  `startEditing(messageId)` (a no-op unless the row is rendered, the viewer's
+  own, confirmed, not known to be gone, the viewer's role when known is not
+  `READ` and the adapter implements `editMessage`; sends nothing, not even a
+  typing update), `cancelEditing()`, `saveEdit(text)` and
+  `deleteMessage(messageId)` (both resolve to a boolean and reject when the
+  adapter lacks the member). `saveEdit` trims the text, sends `null` for an
+  empty caption, never sends an empty text for a text-only message, and always
+  sends the SNAPSHOT's `revision`, never the live row's; the response is
+  merged through the tombstone and precedence guards and edit mode ends. A
+  stale revision (409 `REVISION_CONFLICT`) reloads the row once through
+  `getMessage`, replaces `editingMessage` with it (so the next save carries
+  the fresh revision), reports the conflict through `error` and keeps edit
+  mode; when a row for the edited message with a higher revision reaches the
+  store by itself (a row image, a hydration, a reconcile or a refresh) the
+  same conflict state is entered without a request. A coded 404
+  (`MESSAGE_NOT_FOUND`, on the save or on the conflict reload) removes the
+  row and ends edit mode; any other failure, including a 403 and the uncoded
+  404 a 0.7 backend answers, is reported through `error` without evicting
+  anything and keeps edit mode. `deleteMessage` keeps the row until the server
+  answers (no optimistic removal): success or `MESSAGE_NOT_FOUND` tombstone
+  and remove it (late responses, row images and hydrations for the id are
+  dropped, the acknowledgement target is re-resolved, edit mode on it ends);
+  other failures keep it and report through `error`. A `message_deleted`
+  notification, a reconcile that no longer sees the row or a history eviction
+  also ends edit mode on it.
+- Row precedence. Wherever rows meet (live events, hydration, reconcile,
+  older pages, send and edit responses) the higher `Message.revision` now
+  wins when both rows carry one and at least one is above 0, and a lower
+  revision never overwrites a higher one; equal revisions and rows without a
+  usable revision (pending rows, 0.7 backends where every row is 0) keep the
+  `updatedAt ?? createdAt` rule with its "complete row wins on ties"
+  heuristic. Pending rows are created with `revision: 0`.
+- Default rows. Eligible rows (the viewer's own confirmed rows while the
+  viewer's role is not `READ`, or whatever `canEditMessage` says; never
+  pending rows) render `.ckui-message-actions` with `Edit message` and
+  `Delete message` icon buttons only while the matching callback is present
+  and the adapter supports the action. The actions are always in the DOM;
+  only `@media (hover: hover) and (pointer: fine)` conceals them
+  (`opacity: 0; pointer-events: none`, never `display: none`) until the row is
+  hovered or focused, so touch and keyboard users always see them. `Delete
+  message` opens an inline prompt (`role="group"`, accessible name
+  `Delete this message?`) with `Delete` (`Confirm delete`) and `Cancel`
+  (`Cancel delete`); `confirmDelete` replaces it. Rows with `revision > 0`
+  show `Edited` (`.ckui-message-edited`, accessible name `Edited`) beside the
+  time, for every sender, never on pending rows. Apart from that label, rows
+  that are not eligible, and every row when the callbacks are absent, render
+  byte-identically to 0.7.0.
+- Composer edit mode (`ConversationView`, driven by `editingMessage`).
+  Entering stashes the unsent draft and prefills the field with the message
+  text without a typing update; the submit path (Enter, the primary button,
+  a custom composer's `send`) calls `onSaveEdit(message, text)` instead of
+  `onSendMessage`, without clearing the field first. `false` keeps edit mode
+  and the edited text; any other result, and Cancel (visible `Cancel`,
+  accessible name `Cancel editing`) or Escape, restore the stash and report
+  typing from it (`onTypingChange(stash.trim().length > 0)`). When edit mode
+  ends externally the field keeps text the user changed and restores the
+  stash only when it is empty or still the snapshot's text; a refreshed
+  snapshot for the same message leaves the draft alone. The primary button is
+  `Check` with the accessible name `Save message` (`Send message` otherwise)
+  and is enabled while the field has text or the edited row has attachments
+  (an empty caption clears it); a banner (`.ckui-composer__editing`,
+  `role="status"`) shows `Editing message` with the message's text or
+  attachment count. `#composer` slots receive `editing` and `cancelEdit`
+  while editing.
+- Controlled views. `ConversationView` gains `editingMessage`,
+  `onEditMessage`, `onSaveEdit`, `onCancelEdit`, `onDeleteMessage`,
+  `canEditMessage` and `confirmDelete` (and the `edit-message`, `save-edit`,
+  `cancel-edit`, `delete-message` emits); `MessageListView` gains
+  `onEditMessage`, `onDeleteMessage`, `canEditMessage` and `confirmDelete`.
+  `#message` slots receive `isEdited`, `canEdit`, `canDelete` and, while
+  eligible, `edit()` and `remove()` (`remove` asks `confirmDelete` when the
+  view has one, otherwise deletes at once: a custom row owns its prompt). The
+  bound `Conversation` wires the composable (`editingMessage`,
+  `startEditing`, `saveEdit`, `cancelEditing`, `deleteMessage`) only while the
+  adapter supports each action, forwards `canEditMessage` and
+  `confirmDelete`, and emits the four events like `send-message`.
+- Adapter: optional `editMessage?(messageId, { text, revision })` and
+  `deleteMessage?(messageId)`; the default adapter implements both. Without
+  them nothing renders and `saveEdit` / `deleteMessage` reject. (The Flutter
+  and Android UIs make the members required on their `ConvoKitUiClient`: a
+  breaking change for custom implementers there, like `listInbox` in 0.6.0.)
+  A custom adapter must reject a stale revision with `code:
+  'REVISION_CONFLICT'` and a gone message with `code: 'MESSAGE_NOT_FOUND'`;
+  an uncoded 404 is reported, never treated as a deleted message.
+- Requires core SDK 0.8.x (`editMessage`, `deleteMessage`, the required
+  `Message.revision`, `isEditedMessage`) and the coordinated backend
+  (`PATCH`/`DELETE /api/v1/messages/:id/own`). Consumer-built `Message`
+  literals gain `revision`. Mixed fleet: against a 0.7 backend the author
+  routes answer an uncoded 404 (`HTTP_ERROR`) that surfaces as `error` and
+  keeps the row; every row parses with revision 0, so nothing reads `Edited`
+  and precedence falls back to timestamps. Deleting a message does not
+  retract files other members already received; stored files are reclaimed by
+  the existing user or app deletion cleanup.
+
 ## 0.7.0
 
 - Private mark unread. `useConversationList` / `ConversationListController`

package/PARITY.md

@@ -26,6 +26,23 @@ while using Vue-native composition patterns.
 | Empty marked room clears through `clearConversationUnread` | Yes | Yes | Yes |
 | Adapter `markConversationUnread` / `clearConversationUnread` | Required | Optional | Optional |
 | Inbox 404 fallback to the offset path | Yes | Yes | Yes |
+| Edit / delete own messages (0.8.0: `editingMessage`, `startEditing`, `cancelEditing`, `saveEdit`, `deleteMessage`) | Controller | `useConversation` | `useConversation` |
+| Row precedence by `Message.revision`, timestamps on ties | Yes | Yes | Yes |
+| Default row actions + `Edited` label (accessible names `Edit message` / `Delete message` / `Edited`) | Long press + sheet | `.ckui-message-actions` hover/focus reveal | `.ckui-message-actions` hover/focus reveal |
+| Delete confirmation (`Confirm delete` / `Cancel delete`), `confirmDelete` override | `showDialog` | Inline prompt | Inline prompt |
+| Composer edit mode (banner, `Save message`, `Cancel editing`, caption clearing, draft stash) | Yes | Yes | Yes |
+| Controlled edit surface (`editingMessage`, `onEditMessage`, `onSaveEdit`, `onCancelEdit`, `onDeleteMessage`, `canEditMessage`) | Named params | Props | Props + emits |
+| Row replacements receive `isEdited` / `canEdit` / `canDelete` / `edit` / `remove` | Controller state | Render props | `#message` slot |
+| Adapter `editMessage` / `deleteMessage` | Required | Optional | Optional |
+| Quoted replies (0.9.0: `replyTarget`, `startReply`, `cancelReply`, `Message.replyToMessageId`) | Controller | `useConversation` | `useConversation` |
+| Batched reply previews (`replyPreviews`, one request per burst, `'unavailable'` is terminal) | Controller | Store | Store |
+| Jump to message (0.9.0: `jumpToMessage`, `returnToLatest`, `loadNewerMessages`, `windowMode`) | Controller | `useConversation` | `useConversation` |
+| Quoted block + `Reply to message` action (`Original message unavailable`, `Quoted message`) | Scope builder | `.ckui-message-quote` | `.ckui-message-quote` |
+| Composer reply strip (`Cancel reply`, draft untouched) | Scope builder | Nested `replying` | Flat `replying` / `cancelReply` |
+| Jump highlight + focus (`--ckui-highlight`, `aria-busy` while landing) | `ensureVisible` | `scrollIntoView` | `scrollIntoView` |
+| Controlled reply / jump surface (`replyTarget`, `onJumpToMessage`, `onReturnToLatest`, …) | Named params | Props | Props + emits |
+| Row replacements receive `canReply` / `reply` / `replyPreview` / `jumpToReplyTarget` | Scope object | Render props | `#message` slot |
+| Adapter `getReplyPreviews` / `getMessageContext` | Required | Optional | Optional |
 | Search, archived, participant, predicate, sort filters | Yes | Yes | Yes |
 | Realtime messages, typing, reads | Yes | Yes | Yes |
 | Pending state without provisional timestamps or receipts | Yes | Yes | Yes |
@@ -91,3 +108,32 @@ the TypeScript UIs and required in the Dart and Kotlin ones (a breaking
 change for custom implementers there, like `listInbox` in 0.6.0). The parity
 script checks API presence only; the store, rendered-view and actual-SDK
 protocol tests verify behavior.
+
+## Message-edit parity (0.8.0)
+
+Every UI lets the viewer edit and delete their own confirmed messages through
+the room controller (`editingMessage`, `canEditMessages` /
+`canDeleteMessages`, `startEditing`, `cancelEditing`, `saveEdit`,
+`deleteMessage`), sends the SNAPSHOT's `revision` captured when editing
+started (never the live row's), reloads the row once on 409
+`REVISION_CONFLICT` and refreshes the snapshot so the next save carries the
+fresh revision, enters the same conflict state without a request when a
+newer row for the edited message arrives on its own, removes the row only on
+a coded 404 `MESSAGE_NOT_FOUND` (an uncoded 404 from a 0.7 backend is an
+error that keeps the row and edit mode), and keeps the row until the server
+accepts a deletion. Rows merge by the higher `Message.revision` when both
+carry one and at least one is above 0, falling back to `updatedAt ??
+createdAt` on ties and for pending rows. Default rows offer `Edit message` /
+`Delete message` (web: `.ckui-message-actions`, always in the DOM, concealed
+only under `(hover: hover) and (pointer: fine)` until hover or focus; natives:
+long press or context menu) with a confirmation (`Confirm delete` /
+`Cancel delete`; `confirmDelete` overrides it) and show `Edited` for
+`revision > 0`; rows that are not eligible render as in 0.7.0. The composer's
+single submit path saves while editing, prefills the message text without a
+typing update, stashes and restores the unsent draft, keeps the edited text on
+failure or conflict, and allows an empty caption for a message with
+attachments (`text: null`). The adapter additions are optional in the
+TypeScript UIs and required in the Dart and Kotlin ones (a breaking change for
+custom implementers there, like `listInbox` in 0.6.0); the Swift UI's bound
+view gains `onController`. The parity script checks API presence only; the
+store, rendered-view and actual-SDK protocol tests verify behavior.

package/README.md

@@ -11,6 +11,232 @@ React package: system typography, separated rows, subtle borders, compact
 actions, and restrained radii. It remains framework-CSS independent and does
 not require Tailwind in the host application.
 
+## 0.9.0 quoted replies and jump to message
+
+This release requires JavaScript SDK 0.9.x (`Message.replyToMessageId`,
+`SendMessageInput.replyToMessageId`, `ReplyPreview`, `MessageContextPage`,
+`getReplyPreviews`, `getMessageContext`) and the coordinated backend
+(`GET /api/v1/conversations/:id/reply-previews` and
+`GET /api/v1/conversations/:id/context`). Everything is additive: a room with
+no replies renders exactly as in 0.8.0.
+
+- Who may: any active member may quote any message in the room, own or not,
+  while the viewer's role (the 0.7 `membership`, else the viewer's participant
+  row) is not `READ`; pending rows are never quotable. That is deliberately
+  wider than the edit/delete eligibility, and it is **not** routed through
+  `canEditMessage` — the separate `canReplyToMessage` prop replaces it.
+- Controller members (`useConversation` and the `Conversation` controller):
+  `replyTarget` (the message the composer is quoting, or null),
+  `replyPreviews` (quoted parents by `Message.replyToMessageId`),
+  `highlightedMessageId`, `jumpInFlight`, `windowMode` (`live` or `jumped`),
+  `hasNewerMessages`, `isLoadingNewer`, `canJumpToMessage` /
+  `canResolveReplyPreviews` (adapter support), plus `startReply(messageId)`,
+  `cancelReply()`, `jumpToMessage(messageId)`, `loadNewerMessages()` and
+  `returnToLatest()`. Replying and editing are mutually exclusive: each clears
+  the other. `startReply` sends nothing, and unlike edit mode it leaves the
+  draft alone.
+- Sending: the reply target is stamped on the optimistic row, so the quoted
+  block renders before the server acknowledges the send, and it is cleared
+  only once the send is accepted. A send without a quote omits
+  `replyToMessageId` entirely, so it stays byte-identical to 0.8.0. The
+  reference is write-once: the backend rejects a retry that changes it.
+- Preview resolution is **batched, never per row**: after each page load,
+  reconcile and live-insert burst the store issues one `getReplyPreviews` call
+  for the distinct parents the loaded window cannot derive (a parent that is
+  on screen costs no request). Previews are re-read, never copied: a parent
+  edit, a deletion, or a reconnect invalidates the cached entry. An id that a
+  **resolved** call did not return is cached as the terminal `'unavailable'`
+  and rendered `Original message unavailable`, with the reference and the jump
+  affordance intact. A **rejected** call writes no entry for any of its ids:
+  they stay unresolved (the row renders the reference with no quoted text),
+  the failure surfaces through `error`, and the next trigger asks again.
+- Jump windows: `jumpToMessage` highlights a rendered row without a request;
+  otherwise it **replaces** the window with a context window centred on the
+  target and sets `windowMode: 'jumped'`. A jump is a window operation, never
+  a re-open — tombstones, the acknowledgement floor, this open's captured
+  private state, edit mode and the reply target all survive it. While jumped
+  the store acknowledges nothing, realtime inserts are recorded but not
+  rendered, paging goes through the window's own cursors in both directions,
+  and a queued reconcile re-reads the window with one bounded request instead
+  of walking history from the tail (the tail reconcile stays owed and runs on
+  the return). `returnToLatest()` reloads the newest page, drains the deferred
+  rows and acknowledges them; if it fails the window and the affordance stay.
+  A jump is refused while a send is in flight, and a send from a jumped window
+  returns to the tail first, keeping the draft and the quote.
+- Default rows: a `Reply to message` action joins the existing actions menu,
+  and a reply renders `.ckui-message-quote` above its text with the quoted
+  author and text, `Original message unavailable` when the parent is gone, or
+  the reference alone while the preview is not resolved yet. The block is a
+  button (name `Quoted message from <author>`) whenever the view can jump. The
+  jumped-to row is centred (`scrollIntoView({ block: 'center', behavior:
+  'instant' })`), focused and tinted with `--ckui-highlight` for about two
+  seconds; the list carries `aria-busy="true"` only while the jump lands, and
+  stick-to-bottom, pagination and the highlight clear are suspended for that
+  window. Rows without the new callbacks render byte-identically to 0.8.0.
+- Composer: a cancellable `.ckui-composer__replying` strip (`role="status"`,
+  `Cancel reply`, Escape) sits where the edit banner does. It never replaces
+  the draft. `#composer` slots receive `replying` and `cancelReply`.
+- Controlled views: `ConversationView` accepts `replyTarget`,
+  `onReplyToMessage`, `onCancelReply`, `canReplyToMessage`,
+  `replyPreviewByMessageId`, `onJumpToMessage`, `highlightedMessageId`,
+  `jumpInFlight`, `hasNewerMessages`, `isLoadingNewer`, `onLoadNewer` and
+  `onReturnToLatest` (also as `@reply-to-message`, `@cancel-reply`,
+  `@jump-to-message`, `@load-newer`, `@return-to-latest`);
+  `MessageListView` accepts all of those except `replyTarget`,
+  `onCancelReply` and `onReturnToLatest`. `onReturnToLatest` is what renders
+  the `Jump to latest` control, so pass it only while the window is jumped.
+  `#message` slots receive `canReply`, `reply()`, `replyPreview` and
+  `jumpToReplyTarget()`; the slot wrapper carries `data-message-id` so a
+  replaced row is still a jump target.
+- Adapter additions: `ConvoKitUiClient.getReplyPreviews?(conversationId,
+  messageIds)` and `getMessageContext?(conversationId, options)` are optional;
+  the default adapter implements both. (The Flutter and Android UIs make the
+  same members required on their `ConvoKitUiClient`, a breaking change for
+  custom implementers there.) Replying itself needs no adapter member.
+- Mixed fleet: against a 0.8 backend both routes answer Express's unmatched
+  route with an uncoded 404 (`HTTP_ERROR`). That is **not** "the message is
+  gone": no preview becomes `unavailable` and no window is replaced. After the
+  first such rejection the store sets `canResolveReplyPreviews` /
+  `canJumpToMessage` to false for its life, so the affordance disappears
+  instead of failing repeatedly; a coded `404 MESSAGE_NOT_FOUND` never does
+  that — it is a real missing target and marks that one preview `unavailable`.
+  A 0.8 client against a 0.9 backend simply ignores the new row key.
+
+```vue
+<script setup lang="ts">
+import { ref } from 'vue'
+import type { Message, ReplyPreview } from '@convokitapp/sdk'
+import { ConversationView } from '@convokitapp/vue-ui'
+
+const replyTarget = ref<Message | null>(null)
+const previews = ref(new Map<string, ReplyPreview | 'unavailable'>())
+const highlighted = ref<string | null>(null)
+async function send(text: string) {
+  await api.sendMessage({ text, ...(replyTarget.value ? { replyToMessageId: replyTarget.value.id } : {}) })
+  replyTarget.value = null
+}
+</script>
+
+<template>
+  <ConversationView
+    v-bind="conversationProps"
+    :reply-target="replyTarget"
+    :reply-preview-by-message-id="previews"
+    :highlighted-message-id="highlighted"
+    @send-message="send"
+    @reply-to-message="(message) => (replyTarget = message)"
+    @cancel-reply="replyTarget = null"
+    @jump-to-message="(messageId) => (highlighted = messageId)"
+  />
+</template>
+```
+
+## 0.8.0 edit and delete your own messages
+
+This release requires JavaScript SDK 0.8.x (`editMessage`, `deleteMessage`,
+the required `Message.revision`, `isEditedMessage`) and the coordinated
+backend (`PATCH`/`DELETE /api/v1/messages/:id/own`). Consumer-built `Message`
+literals (fixtures, controlled views) gain `revision`.
+
+- Who may: the viewer's own confirmed messages, while the viewer's role (the
+  0.7 `membership`, else the viewer's participant row) is not `READ`. The
+  server checks the same rules (403 for other members' messages and `READ`
+  roles); custom row eligibility goes through `canEditMessage`.
+- Controller members (`useConversation` and the `Conversation` controller):
+  `editingMessage` (the row being edited as the user saw it; null otherwise),
+  `canEditMessages` / `canDeleteMessages` (adapter support),
+  `startEditing(messageId)`, `cancelEditing()`, `saveEdit(text)` and
+  `deleteMessage(messageId)`. `saveEdit` sends the snapshot's `revision`,
+  never the live row's: a stale one answers 409 `REVISION_CONFLICT`, the
+  store reloads the row once, shows its current content as the new snapshot
+  (the banner and the row update, the draft stays) and reports the conflict
+  through `error`; the next save carries the fresh revision. A newer row for
+  the edited message arriving on its own (row image, hydration, reconcile)
+  enters the same state without a request. A coded 404 `MESSAGE_NOT_FOUND`
+  removes the row and ends edit mode; a 403, a 500, a network failure or the
+  uncoded 404 a 0.7 backend answers keep the row, the history and edit mode
+  and set `error`. `deleteMessage` removes nothing until the server accepts
+  (or answers `MESSAGE_NOT_FOUND`); other devices learn through the room's
+  deletion notification and late responses for a removed id are dropped.
+- Precedence: when rows meet, the higher `Message.revision` wins when both
+  carry one and at least one is above 0; ties and rows without a usable
+  revision keep the `updatedAt ?? createdAt` rule.
+- Default row actions: eligible rows render `.ckui-message-actions` with
+  `Edit message` and `Delete message` buttons, always in the DOM. Only
+  `@media (hover: hover) and (pointer: fine)` conceals them (`opacity` and
+  `pointer-events`, never `display: none`) until the row is hovered or
+  focused; touch and keyboard users always see them. `Delete message` opens an
+  inline prompt (`role="group"`, name `Delete this message?`) with `Delete`
+  (`Confirm delete`) and `Cancel` (`Cancel delete`); pass `confirmDelete` to
+  use your own dialog. Edited rows show `Edited` (name `Edited`) beside the
+  time. Apart from that label, rows that are not eligible, and every row
+  without the callbacks, render byte-identically to 0.7.0.
+- Composer edit mode: entering stashes the unsent draft and prefills the
+  field with the message text without a typing update. Enter, the primary
+  button (`Check`, name `Save message`) or a custom composer's `send` saves;
+  Cancel (name `Cancel editing`) and Escape restore the stash. Save is
+  enabled while the field has text or the message has attachments: an empty
+  caption is sent as `null` and clears it (attachments are never changed). A
+  refused save keeps the edited text and edit mode; a successful one and a
+  cancel restore the stash. `#composer` slots receive `editing` and
+  `cancelEdit` while editing.
+- Controlled views: `ConversationView` accepts `editingMessage`,
+  `onEditMessage`, `onSaveEdit`, `onCancelEdit`, `onDeleteMessage`,
+  `canEditMessage` and `confirmDelete` (also as `@edit-message`, `@save-edit`,
+  `@cancel-edit`, `@delete-message`); `MessageListView` accepts
+  `onEditMessage`, `onDeleteMessage`, `canEditMessage` and `confirmDelete`.
+  Without the callbacks nothing new renders. `#message` slots receive
+  `isEdited`, `canEdit`, `canDelete` and, while eligible, `edit()` and
+  `remove()` (`remove` runs `confirmDelete` when present, otherwise deletes at
+  once). The bound `Conversation` wires the composable, forwards
+  `canEditMessage` and `confirmDelete`, and emits the four events.
+- Adapter additions: `ConvoKitUiClient.editMessage?(messageId, { text,
+  revision })` and `deleteMessage?(messageId)` are optional; the default
+  adapter implements both. Without them the rows render no actions and
+  `saveEdit` / `deleteMessage` reject. (The Flutter and Android UIs make the
+  same members required on their `ConvoKitUiClient`: a breaking change for
+  custom implementers there, like `listInbox` in 0.6.0.) Custom adapters must
+  reject a stale revision with `code: 'REVISION_CONFLICT'` and a gone message
+  with `code: 'MESSAGE_NOT_FOUND'`.
+- Deleting a message removes it and its attachments from the conversation for
+  every member and cannot be undone; files already received or downloaded
+  cannot be retracted, and stored files are reclaimed by the existing user or
+  app deletion cleanup.
+- Mixed fleet: 0.7 clients ignore `revision`; against a 0.7 backend the author
+  routes answer an uncoded 404 (`HTTP_ERROR`) that keeps the row and edit
+  mode, every row parses with revision 0 and nothing reads `Edited`.
+
+```vue
+<script setup lang="ts">
+import { ref } from 'vue'
+import type { Message } from '@convokitapp/sdk'
+import { ConversationView } from '@convokitapp/vue-ui'
+
+const editing = ref<Message | null>(null)
+const rows = ref<Message[]>([])
+async function saveEdit(message: Message, text: string) {
+  // Send message.revision; on 409 REVISION_CONFLICT reload the row and let the user retry.
+  const saved = await api.editMessage(message.id, { text: text || null, revision: message.revision })
+  rows.value = rows.value.map((row) => (row.id === saved.id ? saved : row))
+  editing.value = null
+}
+const confirmDelete = (message: Message) => window.confirm(`Delete "${message.text ?? 'this message'}"?`)
+</script>
+
+<template>
+  <ConversationView
+    v-bind="conversationProps"
+    :messages="rows"
+    :editing-message="editing"
+    @edit-message="(message) => (editing = message)"
+    @save-edit="saveEdit"
+    @cancel-edit="editing = null"
+    @delete-message="(message) => api.deleteMessage(message.id)"
+    :confirm-delete="confirmDelete"
+  />
+</template>
+```
+
 ## 0.7.0 private mark unread
 
 This release requires JavaScript SDK 0.7.x (`markConversationUnread`,
@@ -292,18 +518,28 @@ state directly. Every important surface has a named slot:
   <template #header="{ conversation }">
     <SupportHeader :title="conversation.displayTitle" />
   </template>
-  <template #message="{ message, isCurrentUser, readerIds }">
-    <SupportBubble :message="message" :mine="isCurrentUser" :read-by="readerIds" />
+  <template #message="{ message, isCurrentUser, readerIds, isEdited, edit, remove }">
+    <SupportBubble :message="message" :mine="isCurrentUser" :read-by="readerIds" :edited="isEdited" @edit="edit" @delete="remove" />
   </template>
-  <template #composer="{ value, setValue, send }">
-    <BrandComposer :model-value="value" @update:model-value="setValue" @send="send" />
+  <template #composer="{ value, setValue, send, editing, cancelEdit }">
+    <BrandComposer :model-value="value" :editing="editing" @update:model-value="setValue" @send="send" @cancel="cancelEdit" />
   </template>
 </ConversationView>
 ```
 
+`#message` slots receive `isEdited`, `canEdit`, `canDelete` and, while the row
+is eligible, `edit()` and `remove()`; `#composer` slots receive `editing` and
+`cancelEdit` while the view is in edit mode, and their `send` saves the edit
+(0.8.0).
+
 Available slots include `conversation-item`, `separator`, `header`, `message`,
 `media`, `read-receipt`, `composer`, `typing-indicator`, `loading`, `empty`,
-`error`, `load-more`, `loading-older`, and `message-error`.
+`error`, `load-more`, `loading-older`, `loading-newer`, `jump-to-latest`, and
+`message-error`. `#loading-newer` (in `MessageListView`) replaces the newer-end
+spinner of a jumped window, and `#jump-to-latest` (in `ConversationView`)
+replaces the default `Jump to latest` control, receiving `returnToLatest`
+(`JumpToLatestSlotProps`); both render only while the window is jumped, so a
+live window stays byte-identical to 0.8.0 (0.9.0).
 
 ## Composables
 
@@ -317,6 +553,9 @@ for a host-built row action.
 `useConversation` also exposes `readPositionByUserId`, `readerIdsFor(message)`,
 `markRead()` and `setVisible(visible)`; call `setVisible(false)` while your own
 surface hides the room so automatic acknowledgements wait until it is shown.
+For the viewer's own messages it exposes `editingMessage`, `canEditMessages`,
+`canDeleteMessages`, `startEditing(messageId)`, `cancelEditing()`,
+`saveEdit(text)` and `deleteMessage(messageId)` (0.8.0).
 
 Optimistic rows display `Sending…` until acknowledgement. The final server
 timestamp is formatted in the viewer's local timezone. Custom message slots can