@adatechnology/conversations-ui 0.4.1 → 0.5.0

package/src/participant/participantMessages.test.ts

@@ -0,0 +1,128 @@
+import { describe, expect, it } from 'bun:test'
+
+import type { ParticipantMessage } from '@adatechnology/conversation-contracts'
+
+import type { ParticipantLocalPendingMessage, ParticipantPendingMessage } from './participantApi.types'
+import { isOwnMessage, mergeParticipantMessages, resolveOwnMessageStatus } from './participantMessages'
+
+const SUBJECT = { subjectType: 'trip', subjectId: 'a' }
+const OTHER_SUBJECT = { subjectType: 'trip', subjectId: 'b' }
+
+function server(id: string, createdAt: string, overrides: Partial<ParticipantMessage> = {}): ParticipantMessage {
+  return { id, direction: 'inbound', attachments: [], createdAt, ...overrides }
+}
+function host(clientMessageId: string, createdAt: string, overrides: Partial<ParticipantPendingMessage> = {}): ParticipantPendingMessage {
+  return { clientMessageId, subject: SUBJECT, text: 'x', createdAt, state: 'queued', ...overrides }
+}
+function local(clientMessageId: string, createdAt: string, overrides: Partial<ParticipantLocalPendingMessage> = {}): ParticipantLocalPendingMessage {
+  return { clientMessageId, subject: SUBJECT, text: 'x', createdAt, state: 'sending', ...overrides }
+}
+
+describe('mergeParticipantMessages', () => {
+  it('orders everything by createdAt ascending', () => {
+    const items = mergeParticipantMessages({
+      serverMessages: [server('s2', '2026-10-01T10:02:00.000Z'), server('s1', '2026-10-01T10:00:00.000Z')],
+      hostPending: [host('h1', '2026-10-01T10:03:00.000Z')],
+      localPending: [local('l1', '2026-10-01T10:01:00.000Z')],
+      subject: SUBJECT,
+    })
+    expect(items.map((item) => (item.kind === 'server' ? item.message.id : item.pending.clientMessageId))).toEqual(['s1', 'l1', 's2', 'h1'])
+  })
+
+  it('hides a host pending when a server message has the same clientMessageId', () => {
+    const items = mergeParticipantMessages({
+      serverMessages: [server('s1', '2026-10-01T10:00:00.000Z', { clientMessageId: 'c1' })],
+      hostPending: [host('c1', '2026-10-01T09:59:00.000Z')],
+      localPending: [],
+      subject: SUBJECT,
+    })
+    expect(items).toHaveLength(1)
+    expect(items[0]?.kind).toBe('server')
+  })
+
+  it('ignores host pending of another subject', () => {
+    const items = mergeParticipantMessages({
+      serverMessages: [],
+      hostPending: [host('c1', '2026-10-01T09:59:00.000Z', { subject: OTHER_SUBJECT })],
+      localPending: [],
+      subject: SUBJECT,
+    })
+    expect(items).toHaveLength(0)
+  })
+
+  it('maps host pending states and tags the origin', () => {
+    const items = mergeParticipantMessages({
+      serverMessages: [],
+      hostPending: [host('q', '2026-10-01T10:00:00.000Z'), host('f', '2026-10-01T10:01:00.000Z', { state: 'failed' })],
+      localPending: [],
+      subject: SUBJECT,
+    })
+    expect(items.map((item) => (item.kind === 'pending' ? [item.origin, item.displayState] : []))).toEqual([
+      ['host', 'queued'],
+      ['host', 'failed'],
+    ])
+  })
+
+  it('shows local pending as sending or failed when no other source has it', () => {
+    const items = mergeParticipantMessages({
+      serverMessages: [],
+      hostPending: [],
+      localPending: [local('a', '2026-10-01T10:00:00.000Z'), local('b', '2026-10-01T10:01:00.000Z', { state: 'failed' })],
+      subject: SUBJECT,
+    })
+    expect(items.map((item) => (item.kind === 'pending' ? [item.origin, item.displayState] : []))).toEqual([
+      ['local', 'sending'],
+      ['local', 'failed'],
+    ])
+  })
+
+  it('hides a local pending already present on the server or at the host', () => {
+    const items = mergeParticipantMessages({
+      serverMessages: [server('s1', '2026-10-01T10:00:00.000Z', { clientMessageId: 'a' })],
+      hostPending: [host('b', '2026-10-01T10:01:00.000Z')],
+      localPending: [local('a', '2026-10-01T09:59:00.000Z'), local('b', '2026-10-01T09:59:30.000Z')],
+      subject: SUBJECT,
+    })
+    expect(items.map((item) => item.kind)).toEqual(['server', 'pending'])
+    expect(items[1]).toMatchObject({ kind: 'pending', origin: 'host' })
+  })
+
+  it('keeps a failed local pending with its original clientMessageId for resend', () => {
+    const items = mergeParticipantMessages({
+      serverMessages: [],
+      hostPending: [],
+      localPending: [local('keep-me', '2026-10-01T10:00:00.000Z', { state: 'failed' })],
+      subject: SUBJECT,
+    })
+    expect(items[0]).toMatchObject({ kind: 'pending', pending: { clientMessageId: 'keep-me' } })
+  })
+})
+
+describe('isOwnMessage', () => {
+  it('treats inbound (company perspective) as the participant own message', () => {
+    expect(isOwnMessage(server('s', '2026-10-01T10:00:00.000Z', { direction: 'inbound' }))).toBe(true)
+    expect(isOwnMessage(server('s', '2026-10-01T10:00:00.000Z', { direction: 'outbound' }))).toBe(false)
+  })
+})
+
+describe('resolveOwnMessageStatus', () => {
+  it('uses the local display state for pending messages', () => {
+    expect(resolveOwnMessageStatus({ displayState: 'sending', confirmsRead: true })).toBe('sending')
+    expect(resolveOwnMessageStatus({ displayState: 'queued', confirmsRead: true })).toBe('queued')
+    expect(resolveOwnMessageStatus({ displayState: 'failed', confirmsRead: true })).toBe('failed')
+  })
+  it('defaults to sent without server status', () => {
+    expect(resolveOwnMessageStatus({ confirmsRead: true })).toBe('sent')
+  })
+  it('maps server statuses', () => {
+    expect(resolveOwnMessageStatus({ serverStatus: 'queued', confirmsRead: true })).toBe('queued')
+    expect(resolveOwnMessageStatus({ serverStatus: 'sent', confirmsRead: true })).toBe('sent')
+    expect(resolveOwnMessageStatus({ serverStatus: 'delivered', confirmsRead: true })).toBe('delivered')
+    expect(resolveOwnMessageStatus({ serverStatus: 'failed', confirmsRead: true })).toBe('failed')
+    expect(resolveOwnMessageStatus({ serverStatus: 'bounced', confirmsRead: true })).toBe('failed')
+  })
+  it('reports read only when the channel confirms it', () => {
+    expect(resolveOwnMessageStatus({ serverStatus: 'read', confirmsRead: true })).toBe('read')
+    expect(resolveOwnMessageStatus({ serverStatus: 'read', confirmsRead: false })).toBe('delivered')
+  })
+})

package/src/participant/participantMessages.ts

@@ -0,0 +1,73 @@
+import type { MessageDeliveryStatus, ParticipantMessage, ParticipantSubjectRef } from '@adatechnology/conversation-contracts'
+
+import type { ParticipantLocalPendingMessage, ParticipantPendingMessage } from './participantApi.types'
+
+export type ParticipantPendingDisplayState = 'sending' | 'queued' | 'failed' | 'sent'
+export type ParticipantOwnMessageStatus = 'sending' | 'queued' | 'sent' | 'delivered' | 'read' | 'failed'
+
+export type ParticipantTimelineItem =
+  | { readonly kind: 'server'; readonly message: ParticipantMessage }
+  | {
+      readonly kind: 'pending'
+      readonly pending: ParticipantPendingMessage | ParticipantLocalPendingMessage
+      readonly origin: 'host' | 'local'
+      readonly displayState: ParticipantPendingDisplayState
+    }
+
+export type MergeParticipantMessagesParams = {
+  readonly serverMessages: readonly ParticipantMessage[]
+  readonly hostPending: readonly ParticipantPendingMessage[]
+  readonly localPending: readonly ParticipantLocalPendingMessage[]
+  readonly subject: ParticipantSubjectRef
+}
+
+export type ResolveOwnMessageStatusParams = {
+  readonly displayState?: ParticipantPendingDisplayState
+  readonly serverStatus?: MessageDeliveryStatus
+  readonly confirmsRead: boolean
+}
+
+function isSameSubject(left: ParticipantSubjectRef, right: ParticipantSubjectRef): boolean {
+  return left.subjectType === right.subjectType && left.subjectId === right.subjectId
+}
+
+function createdAtOf(item: ParticipantTimelineItem): number {
+  return Date.parse(item.kind === 'server' ? item.message.createdAt : item.pending.createdAt)
+}
+
+export function mergeParticipantMessages(params: MergeParticipantMessagesParams): readonly ParticipantTimelineItem[] {
+  const { serverMessages, hostPending, localPending, subject } = params
+  const knownClientIds = new Set<string>()
+  for (const message of serverMessages) {
+    if (message.clientMessageId) knownClientIds.add(message.clientMessageId)
+  }
+
+  const items: ParticipantTimelineItem[] = serverMessages.map((message) => ({ kind: 'server', message }))
+
+  for (const pending of hostPending) {
+    if (!isSameSubject(pending.subject, subject) || knownClientIds.has(pending.clientMessageId)) continue
+    knownClientIds.add(pending.clientMessageId)
+    items.push({ kind: 'pending', pending, origin: 'host', displayState: pending.state })
+  }
+
+  for (const pending of localPending) {
+    if (!isSameSubject(pending.subject, subject) || knownClientIds.has(pending.clientMessageId)) continue
+    items.push({ kind: 'pending', pending, origin: 'local', displayState: pending.state })
+  }
+
+  return items.sort((left, right) => createdAtOf(left) - createdAtOf(right))
+}
+
+/** Direction is from the company perspective: the participant is the inbound side. */
+export function isOwnMessage(message: ParticipantMessage): boolean {
+  return message.direction === 'inbound'
+}
+
+export function resolveOwnMessageStatus(params: ResolveOwnMessageStatusParams): ParticipantOwnMessageStatus {
+  const { displayState, serverStatus, confirmsRead } = params
+  if (displayState) return displayState
+  if (serverStatus === undefined) return 'sent'
+  if (serverStatus === 'failed' || serverStatus === 'bounced') return 'failed'
+  if (serverStatus === 'read') return confirmsRead ? 'read' : 'delivered'
+  return serverStatus
+}

package/src/participant/participantNewMessages.test.ts

@@ -0,0 +1,54 @@
+import { describe, expect, it } from 'bun:test'
+
+import { buildMessage } from './participantFixtures.test-helper'
+import { collectServerMessageIds, countNewIncomingMessages } from './participantNewMessages'
+import type { ParticipantTimelineItem } from './participantMessages'
+
+function server(id: string, direction: 'inbound' | 'outbound', createdAt = '2026-10-01T10:00:00.000Z'): ParticipantTimelineItem {
+  return { kind: 'server', message: buildMessage({ id, direction, createdAt }) }
+}
+
+describe('countNewIncomingMessages', () => {
+  it('counts only unseen messages from the other side (outbound)', () => {
+    const items = [
+      server('a', 'outbound', '2026-10-01T10:00:00.000Z'),
+      server('b', 'outbound', '2026-10-01T10:01:00.000Z'),
+      server('c', 'inbound', '2026-10-01T10:02:00.000Z'),
+      server('d', 'outbound', '2026-10-01T10:03:00.000Z'),
+    ]
+    expect(countNewIncomingMessages(new Set(['a']), items)).toBe(2)
+  })
+
+  it('does not count outbound history loaded above the messages already seen', () => {
+    const seen = [server('m30', 'outbound', '2026-10-01T10:30:00.000Z'), server('m31', 'inbound', '2026-10-01T10:31:00.000Z')]
+    const older = [server('m1', 'outbound', '2026-10-01T10:01:00.000Z'), server('m2', 'outbound', '2026-10-01T10:02:00.000Z')]
+    expect(countNewIncomingMessages(collectServerMessageIds(seen), [...older, ...seen])).toBe(0)
+  })
+
+  it('counts a reply that arrives after the messages already seen', () => {
+    const seen = [server('m30', 'outbound', '2026-10-01T10:30:00.000Z'), server('m31', 'inbound', '2026-10-01T10:31:00.000Z')]
+    const reply = server('m32', 'outbound', '2026-10-01T10:32:00.000Z')
+    expect(countNewIncomingMessages(collectServerMessageIds(seen), [...seen, reply])).toBe(1)
+  })
+
+  it('is zero when everything was seen', () => {
+    const items = [server('a', 'outbound')]
+    expect(countNewIncomingMessages(collectServerMessageIds(items), items)).toBe(0)
+  })
+
+  it('ignores the pending messages of the participant', () => {
+    const pending: ParticipantTimelineItem = {
+      kind: 'pending',
+      origin: 'local',
+      displayState: 'sending',
+      pending: { clientMessageId: 'x', subject: { subjectType: 'invoice', subjectId: '1' }, createdAt: '2026-10-01T10:00:00.000Z', state: 'sending', text: 'hi' },
+    }
+    expect(countNewIncomingMessages(new Set(), [pending])).toBe(0)
+  })
+})
+
+describe('collectServerMessageIds', () => {
+  it('collects the ids of server items only', () => {
+    expect([...collectServerMessageIds([server('a', 'inbound'), server('b', 'outbound')])]).toEqual(['a', 'b'])
+  })
+})

package/src/participant/participantNewMessages.ts

@@ -0,0 +1,29 @@
+import type { ParticipantTimelineItem } from './participantMessages'
+
+export function collectServerMessageIds(items: readonly ParticipantTimelineItem[]): ReadonlySet<string> {
+  const ids = new Set<string>()
+  for (const item of items) {
+    if (item.kind === 'server') ids.add(item.message.id)
+  }
+  return ids
+}
+
+function latestSeenTime(previousIds: ReadonlySet<string>, items: readonly ParticipantTimelineItem[]): number {
+  let latest = Number.NEGATIVE_INFINITY
+  for (const item of items) {
+    if (item.kind === 'server' && previousIds.has(item.message.id)) latest = Math.max(latest, Date.parse(item.message.createdAt))
+  }
+  return latest
+}
+
+/** Messages from the other side ('outbound') newer than what the participant has seen; older history loaded above is not news. */
+export function countNewIncomingMessages(previousIds: ReadonlySet<string>, currentItems: readonly ParticipantTimelineItem[]): number {
+  const latestSeen = latestSeenTime(previousIds, currentItems)
+  return currentItems.filter(
+    (item) =>
+      item.kind === 'server' &&
+      item.message.direction === 'outbound' &&
+      !previousIds.has(item.message.id) &&
+      Date.parse(item.message.createdAt) > latestSeen,
+  ).length
+}

package/src/participant/participantQuickReply.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'bun:test'
+
+import { applyQuickReply } from './participantQuickReply'
+
+describe('applyQuickReply', () => {
+  it('fills an empty text with the reply', () => {
+    expect(applyQuickReply('', 'On my way')).toBe('On my way')
+    expect(applyQuickReply('   ', 'On my way')).toBe('On my way')
+  })
+
+  it('appends to existing text separated by a space', () => {
+    expect(applyQuickReply('Hello', 'On my way')).toBe('Hello On my way')
+  })
+
+  it('does not double the separator when the text already ends in whitespace', () => {
+    expect(applyQuickReply('Hello ', 'On my way')).toBe('Hello On my way')
+    expect(applyQuickReply('Hello\n', 'On my way')).toBe('Hello\nOn my way')
+  })
+
+  it('returns the text untouched for an empty reply', () => {
+    expect(applyQuickReply('Hello', '')).toBe('Hello')
+  })
+})

package/src/participant/participantQuickReply.ts

@@ -0,0 +1,6 @@
+/** Fills the composer text with a quick reply; the caller must never send because of it. */
+export function applyQuickReply(currentText: string, replyText: string): string {
+  if (replyText === '') return currentText
+  if (currentText.trim() === '') return replyText
+  return /\s$/.test(currentText) ? `${currentText}${replyText}` : `${currentText} ${replyText}`
+}

package/src/participant/participantScroll.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, it } from 'bun:test'
+
+import {
+  NEAR_BOTTOM_THRESHOLD_PX,
+  resolveScrollAction,
+  scrollAnchorAfterPrepend,
+  shouldStickToBottom,
+} from './participantScroll'
+
+describe('shouldStickToBottom', () => {
+  const base = { clientHeight: 400, scrollHeight: 1000, threshold: 80 }
+
+  it('is true at the very bottom', () => {
+    expect(shouldStickToBottom({ ...base, scrollTop: 600 })).toBe(true)
+  })
+
+  it('is true within the threshold and false beyond it', () => {
+    expect(shouldStickToBottom({ ...base, scrollTop: 520 })).toBe(true)
+    expect(shouldStickToBottom({ ...base, scrollTop: 519 })).toBe(false)
+  })
+
+  it('is true when the content fits without scrolling', () => {
+    expect(shouldStickToBottom({ scrollTop: 0, clientHeight: 400, scrollHeight: 300, threshold: 80 })).toBe(true)
+  })
+
+  it('uses an 80px default threshold', () => {
+    expect(NEAR_BOTTOM_THRESHOLD_PX).toBe(80)
+  })
+})
+
+describe('scrollAnchorAfterPrepend', () => {
+  it('keeps the same message in view by adding the height that was prepended', () => {
+    expect(scrollAnchorAfterPrepend({ previousScrollTop: 10, previousScrollHeight: 1000, scrollHeight: 1600 })).toBe(610)
+  })
+
+  it('does not move when nothing was prepended', () => {
+    expect(scrollAnchorAfterPrepend({ previousScrollTop: 10, previousScrollHeight: 1000, scrollHeight: 1000 })).toBe(10)
+  })
+})
+
+describe('resolveScrollAction', () => {
+  const settled = { hasPositioned: true, previousFirstKey: 'a', previousLastKey: 'c', firstKey: 'a', lastKey: 'c', wasNearBottom: true }
+
+  it('does nothing while there are no items', () => {
+    expect(resolveScrollAction({ ...settled, hasPositioned: false, firstKey: undefined, lastKey: undefined })).toBe('none')
+  })
+
+  it('jumps to the bottom on the first load even when the user was not near the bottom', () => {
+    expect(resolveScrollAction({ ...settled, hasPositioned: false, previousFirstKey: undefined, previousLastKey: undefined, wasNearBottom: false })).toBe('bottom')
+  })
+
+  it('follows a new last message only when the user was near the bottom', () => {
+    expect(resolveScrollAction({ ...settled, lastKey: 'd' })).toBe('bottom')
+    expect(resolveScrollAction({ ...settled, lastKey: 'd', wasNearBottom: false })).toBe('none')
+  })
+
+  it('anchors when older messages are prepended, whatever the position', () => {
+    expect(resolveScrollAction({ ...settled, firstKey: 'z' })).toBe('anchor')
+    expect(resolveScrollAction({ ...settled, firstKey: 'z', wasNearBottom: false })).toBe('anchor')
+  })
+
+  it('anchors when both ends changed but the user was reading', () => {
+    expect(resolveScrollAction({ ...settled, firstKey: 'z', lastKey: 'd', wasNearBottom: false })).toBe('anchor')
+  })
+
+  it('does nothing when the keys are the same', () => {
+    expect(resolveScrollAction(settled)).toBe('none')
+  })
+})

package/src/participant/participantScroll.ts

@@ -0,0 +1,43 @@
+export const NEAR_BOTTOM_THRESHOLD_PX = 80
+
+export type ShouldStickToBottomParams = {
+  readonly scrollTop: number
+  readonly clientHeight: number
+  readonly scrollHeight: number
+  readonly threshold: number
+}
+
+export type ScrollAnchorAfterPrependParams = {
+  readonly previousScrollTop: number
+  readonly previousScrollHeight: number
+  readonly scrollHeight: number
+}
+
+export type ResolveScrollActionParams = {
+  readonly hasPositioned: boolean
+  readonly previousFirstKey: string | undefined
+  readonly previousLastKey: string | undefined
+  readonly firstKey: string | undefined
+  readonly lastKey: string | undefined
+  readonly wasNearBottom: boolean
+}
+
+export type ScrollAction = 'none' | 'bottom' | 'anchor'
+
+export function shouldStickToBottom(params: ShouldStickToBottomParams): boolean {
+  const { scrollTop, clientHeight, scrollHeight, threshold } = params
+  return scrollHeight - scrollTop - clientHeight <= threshold
+}
+
+export function scrollAnchorAfterPrepend(params: ScrollAnchorAfterPrependParams): number {
+  return params.previousScrollTop + (params.scrollHeight - params.previousScrollHeight)
+}
+
+export function resolveScrollAction(params: ResolveScrollActionParams): ScrollAction {
+  const { firstKey, lastKey } = params
+  if (firstKey === undefined || lastKey === undefined) return 'none'
+  if (!params.hasPositioned) return 'bottom'
+  if (lastKey !== params.previousLastKey && params.wasNearBottom) return 'bottom'
+  if (firstKey !== params.previousFirstKey) return 'anchor'
+  return 'none'
+}

package/src/participant/participantSendController.test.ts

@@ -0,0 +1,201 @@
+import { describe, expect, it } from 'bun:test'
+
+import type { ParticipantMessage } from '@adatechnology/conversation-contracts'
+
+import {
+  appendEntryToDraft,
+  collectKnownClientMessageIds,
+  createParticipantSendEntry,
+  findFailedEntry,
+  hasSendingEntry,
+  participantSendReducer,
+  toLocalPending,
+  type ParticipantSendEntry,
+} from './participantSendController'
+import { participantSendStatesReducer, selectSendEntries } from './participantSendStates'
+import { takeDraftForSend, setDraft } from './participantDrafts'
+
+const TRIP_A = { subjectType: 'trip', subjectId: 'a' }
+const TRIP_B = { subjectType: 'trip', subjectId: 'b' }
+
+function entry(clientMessageId: string, overrides: Partial<ParticipantSendEntry> = {}): ParticipantSendEntry {
+  return createParticipantSendEntry({
+    clientMessageId,
+    subject: TRIP_A,
+    content: { text: 'hello', files: [] },
+    createdAt: '2026-10-01T10:00:00.000Z',
+    ...overrides,
+  })
+}
+
+function serverMessage(id: string, clientMessageId?: string): ParticipantMessage {
+  return { id, direction: 'inbound', attachments: [], createdAt: '2026-10-01T10:00:00.000Z', ...(clientMessageId ? { clientMessageId } : {}) }
+}
+
+function states(entries: readonly ParticipantSendEntry[]) {
+  return entries.map((item) => [item.clientMessageId, item.state])
+}
+
+describe('participantSendReducer', () => {
+  it('starting a send registers a sending entry holding text and files', () => {
+    const file = new File(['x'], 'a.png', { type: 'image/png' })
+    const started = participantSendReducer([], {
+      type: 'started',
+      entry: entry('c1', { files: [file] }),
+    })
+
+    expect(states(started)).toEqual([['c1', 'sending']])
+    expect(started[0]?.files).toEqual([file])
+    expect(started[0]?.text).toBe('hello')
+  })
+
+  it('a sent send stays visible as sent, holding the server message, until the echo is reflected', () => {
+    const sending = participantSendReducer([], { type: 'started', entry: entry('c1') })
+    const message = serverMessage('m1', 'c1')
+    const sent = participantSendReducer(sending, { type: 'sent', clientMessageId: 'c1', message })
+
+    expect(states(sent)).toEqual([['c1', 'sent']])
+    expect(sent[0]?.sentMessage).toBe(message)
+    expect(toLocalPending(sent)[0]?.state).toBe('sent')
+  })
+
+  it('a sent entry survives leaving and coming back, and reflected removes it once the echo exists', () => {
+    const subjectStates = participantSendStatesReducer(new Map(), { subject: TRIP_A, action: { type: 'started', entry: entry('c1') } })
+    const afterSent = participantSendStatesReducer(subjectStates, {
+      subject: TRIP_A,
+      action: { type: 'sent', clientMessageId: 'c1', message: serverMessage('m1', 'c1') },
+    })
+    expect(states(selectSendEntries(afterSent, TRIP_A))).toEqual([['c1', 'sent']])
+
+    const notYet = participantSendStatesReducer(afterSent, { subject: TRIP_A, action: { type: 'reflected', knownClientMessageIds: new Set() } })
+    expect(states(selectSendEntries(notYet, TRIP_A))).toEqual([['c1', 'sent']])
+    const echoed = participantSendStatesReducer(afterSent, { subject: TRIP_A, action: { type: 'reflected', knownClientMessageIds: new Set(['c1']) } })
+    expect(selectSendEntries(echoed, TRIP_A)).toEqual([])
+  })
+
+  it('queued stays visible as queued until the host or the server reflect the id', () => {
+    const sending = participantSendReducer([], { type: 'started', entry: entry('c1') })
+    const queued = participantSendReducer(sending, { type: 'queued', clientMessageId: 'c1' })
+
+    expect(states(queued)).toEqual([['c1', 'queued']])
+    expect(states(participantSendReducer(queued, { type: 'reflected', knownClientMessageIds: new Set() }))).toEqual([['c1', 'queued']])
+    expect(participantSendReducer(queued, { type: 'reflected', knownClientMessageIds: new Set(['c1']) })).toEqual([])
+  })
+
+  it('reflecting an unknown id returns the same reference (no rerender)', () => {
+    const queued = participantSendReducer([], { type: 'started', entry: entry('c1') })
+    expect(participantSendReducer(queued, { type: 'reflected', knownClientMessageIds: new Set(['other']) })).toBe(queued)
+  })
+
+  it('a throw marks failed keeping text and files; retry reuses the same id and goes back to sending', () => {
+    const file = new File(['x'], 'a.png')
+    const failed = participantSendReducer(participantSendReducer([], { type: 'started', entry: entry('c1', { files: [file] }) }), {
+      type: 'failed',
+      clientMessageId: 'c1',
+    })
+
+    expect(findFailedEntry(failed, 'c1')?.files).toEqual([file])
+    const retried = participantSendReducer(failed, { type: 'retried', clientMessageId: 'c1' })
+    expect(states(retried)).toEqual([['c1', 'sending']])
+    expect(retried[0]?.text).toBe('hello')
+  })
+
+  it('retry only applies to failed entries', () => {
+    const sending = participantSendReducer([], { type: 'started', entry: entry('c1') })
+    expect(participantSendReducer(sending, { type: 'retried', clientMessageId: 'c1' })).toBe(sending)
+    expect(findFailedEntry(sending, 'c1')).toBeUndefined()
+  })
+
+  it('discard removes the pending', () => {
+    const failed = participantSendReducer(participantSendReducer([], { type: 'started', entry: entry('c1') }), { type: 'failed', clientMessageId: 'c1' })
+    expect(participantSendReducer(failed, { type: 'discarded', clientMessageId: 'c1' })).toEqual([])
+  })
+
+  it('edit returns text and files to the draft, with the current field content kept after them', () => {
+    const file = new File(['x'], 'a.png')
+    const other = new File(['y'], 'b.png')
+    const failed = entry('c1', { files: [file], state: 'failed' })
+
+    expect(appendEntryToDraft(failed, { text: '', files: [] })).toEqual({ text: 'hello', files: [file] })
+    expect(appendEntryToDraft(failed, { text: 'typed', files: [other] })).toEqual({ text: 'hello\ntyped', files: [file, other] })
+  })
+
+  it('maps entries to local pending messages without the files', () => {
+    const file = new File(['x'], 'a.png', { type: 'image/png' })
+    const [pending] = toLocalPending([entry('c1', { files: [file], state: 'queued' })])
+
+    expect(pending).toMatchObject({ clientMessageId: 'c1', state: 'queued', text: 'hello' })
+    expect(pending?.attachments).toEqual([{ filename: 'a.png', mimeType: 'image/png', sizeBytes: 1 }])
+    expect(pending).not.toHaveProperty('files')
+  })
+
+  it('collects the ids known by the server and by the host queue', () => {
+    const known = collectKnownClientMessageIds({
+      messages: [serverMessage('m1', 'c1'), serverMessage('m2')],
+      hostPending: [{ clientMessageId: 'c2', subject: TRIP_A, createdAt: '2026-10-01T10:00:00.000Z', state: 'queued' }],
+    })
+    expect([...known].sort()).toEqual(['c1', 'c2'])
+  })
+})
+
+describe('send flow with the double tap', () => {
+  it('the second tap finds the field already empty and sends nothing', () => {
+    const drafts = setDraft(new Map(), TRIP_A, { text: '  hello  ', files: [] })
+
+    const first = takeDraftForSend(drafts, TRIP_A)
+    const second = takeDraftForSend(first.drafts, TRIP_A)
+
+    expect(first.content).toEqual({ text: 'hello' })
+    expect(second.content).toBeUndefined()
+  })
+
+  it('an empty or whitespace-only field sends nothing and keeps the drafts reference', () => {
+    const drafts = setDraft(new Map(), TRIP_A, { text: '   ', files: [] })
+    const taken = takeDraftForSend(drafts, TRIP_A)
+
+    expect(taken.content).toBeUndefined()
+    expect(taken.drafts).toBe(drafts)
+  })
+
+  it('failure then edit hands the content back to the draft and leaves a single owner', () => {
+    const drafts = setDraft(new Map(), TRIP_A, { text: 'hello', files: [] })
+    const { drafts: cleared, content } = takeDraftForSend(drafts, TRIP_A)
+    const started = participantSendReducer([], {
+      type: 'started',
+      entry: createParticipantSendEntry({ clientMessageId: 'c1', subject: TRIP_A, content: content ?? { files: [] }, createdAt: '2026-10-01T10:00:00.000Z' }),
+    })
+    const failed = participantSendReducer(started, { type: 'failed', clientMessageId: 'c1' })
+    const failedEntry = findFailedEntry(failed, 'c1')
+
+    expect(cleared.get('trip:a')).toBeUndefined()
+    expect(failedEntry && appendEntryToDraft(failedEntry, { text: '', files: [] })).toEqual({ text: 'hello', files: [] })
+    expect(participantSendReducer(failed, { type: 'discarded', clientMessageId: 'c1' })).toEqual([])
+  })
+})
+
+describe('participantSendStatesReducer', () => {
+  it('keeps the entries per subject so leaving and coming back does not lose a failed message', () => {
+    const afterA = participantSendStatesReducer(new Map(), { subject: TRIP_A, action: { type: 'started', entry: entry('c1') } })
+    const afterFailed = participantSendStatesReducer(afterA, { subject: TRIP_A, action: { type: 'failed', clientMessageId: 'c1' } })
+
+    expect(states(selectSendEntries(afterFailed, TRIP_A))).toEqual([['c1', 'failed']])
+    expect(selectSendEntries(afterFailed, TRIP_B)).toEqual([])
+  })
+
+  it('drops the subject key when its last entry goes away and ignores no-ops by reference', () => {
+    const started = participantSendStatesReducer(new Map(), { subject: TRIP_A, action: { type: 'started', entry: entry('c1') } })
+    const noop = participantSendStatesReducer(started, { subject: TRIP_A, action: { type: 'reflected', knownClientMessageIds: new Set() } })
+    const gone = participantSendStatesReducer(started, { subject: TRIP_A, action: { type: 'discarded', clientMessageId: 'c1' } })
+
+    expect(noop).toBe(started)
+    expect(gone.size).toBe(0)
+  })
+})
+
+describe('hasSendingEntry', () => {
+  it('is true only while some send is in the sending state', () => {
+    expect(hasSendingEntry([])).toBe(false)
+    expect(hasSendingEntry([entry('a', { state: 'failed' }), entry('b', { state: 'queued' })])).toBe(false)
+    expect(hasSendingEntry([entry('a', { state: 'failed' }), entry('b', { state: 'sending' })])).toBe(true)
+  })
+})