@adatechnology/conversations-ui 0.1.0 → 0.2.0

package/src/workspace/QueuedAttachmentsList.tsx

@@ -0,0 +1,198 @@
+/**
+ * Fila de anexos do composer — itens `local` (ainda não subiram) e `stored` (mensagem pronta,
+ * enviados por referência). Mostra nome, tipo, tamanho, miniatura de imagem sob demanda e o estado
+ * de envio de cada item (QR-32, QR-33, QR-47).
+ */
+
+import { useEffect, useRef, useState } from 'react'
+
+import { formatFileSize } from '../lib/format'
+import { attachmentKey, type AttachmentSendStatus } from '../quickReplies/quickReplyAttachments'
+import type { QueuedAttachment } from '../quickReplies/quickReply.types'
+
+export type QueuedAttachmentsListLabels = {
+  readonly remove: string
+  readonly waiting: string
+  readonly sending: string
+  readonly sent: string
+  readonly failed: string
+  readonly skipped: string
+  readonly retry: string
+}
+
+export type QueuedAttachmentsListProps = {
+  readonly items: readonly QueuedAttachment[]
+  readonly statusOf: (key: string) => AttachmentSendStatus
+  readonly onRemove: (item: QueuedAttachment) => void
+  readonly onRetry?: (item: QueuedAttachment) => void
+  /** Chaves com retry avulso em voo — desabilita o botão "Tentar de novo" desse item específico. */
+  readonly retryingKeys?: ReadonlySet<string>
+  readonly getThumbnailUrl?: (uploadId: string) => Promise<string>
+  readonly labels: QueuedAttachmentsListLabels
+  readonly busy: boolean
+}
+
+function nameOf(item: QueuedAttachment): string {
+  return item.kind === 'local' ? item.file.name : item.filename
+}
+
+function mimeTypeOf(item: QueuedAttachment): string {
+  return item.kind === 'local' ? item.file.type : item.mimeType
+}
+
+function sizeOf(item: QueuedAttachment): number {
+  return item.kind === 'local' ? item.file.size : item.sizeBytes
+}
+
+/** Espaço reservado do tamanho final enquanto a miniatura carrega — sem pulo de layout (QR-47). */
+function AttachmentThumbnail({
+  item,
+  getThumbnailUrl,
+}: {
+  readonly item: QueuedAttachment
+  readonly getThumbnailUrl?: (uploadId: string) => Promise<string>
+}) {
+  const isImage = mimeTypeOf(item).startsWith('image/')
+  const [url, setUrl] = useState<string | undefined>(item.kind === 'local' ? undefined : item.previewUrl)
+  const localFile = item.kind === 'local' ? item.file : undefined
+  const uploadId = item.kind === 'stored' ? item.uploadId : undefined
+
+  // Só o `File` decide a URL de objeto local: incluir `item` inteiro (H4) recriava e revogava a URL
+  // a cada render em que a identidade do objeto da fila mudasse por outro motivo (status, por ex.).
+  useEffect(() => {
+    if (!isImage || !localFile) return
+    const objectUrl = URL.createObjectURL(localFile)
+    setUrl(objectUrl)
+    return () => URL.revokeObjectURL(objectUrl)
+  }, [isImage, localFile])
+
+  // `url` fica de fora do array por propósito: é este efeito que o define via `setUrl`, incluí-lo
+  // reexecutaria a busca a cada resolução. Só `uploadId` reinicia a busca da miniatura remota.
+  useEffect(() => {
+    if (!isImage || !uploadId || !getThumbnailUrl) return
+    let cancelled = false
+    getThumbnailUrl(uploadId)
+      .then((resolved) => {
+        if (!cancelled) setUrl(resolved)
+      })
+      .catch(() => undefined)
+    return () => {
+      cancelled = true
+    }
+  }, [isImage, uploadId, getThumbnailUrl])
+
+  if (!isImage) return null
+  return (
+    <span className="cv-attachment-item__thumbnail" aria-hidden="true">
+      {url ? <img src={url} alt="" /> : null}
+    </span>
+  )
+}
+
+/**
+ * Parte pura da transição: quais itens saíram da fila entre a última lista renderizada e a nova.
+ * Separada de `useDepartingItems` para ser testável sem montar um componente.
+ */
+export function departedItemsOf(
+  previouslyRendered: readonly QueuedAttachment[],
+  items: readonly QueuedAttachment[],
+): readonly QueuedAttachment[] {
+  const currentKeys = new Set(items.map(attachmentKey))
+  return previouslyRendered.filter((item) => !currentKeys.has(attachmentKey(item)))
+}
+
+/** Mantém o item visível por uma transição curta depois de sair da fila (QR-47), sem travar props. */
+function useDepartingItems(items: readonly QueuedAttachment[]) {
+  const [rendered, setRendered] = useState(items)
+  const [departingKeys, setDepartingKeys] = useState<ReadonlySet<string>>(new Set())
+  // Espelha `rendered` num ref lido dentro do efeito: assim o array de dependências fica completo
+  // (só `items`, que é o que deve reiniciar a transição) sem o efeito reagir à própria escrita em
+  // `rendered` via `setRendered`, o que recriaria o timer em loop.
+  const renderedRef = useRef(rendered)
+  renderedRef.current = rendered
+
+  useEffect(() => {
+    const removedItems = departedItemsOf(renderedRef.current, items)
+    if (removedItems.length === 0) {
+      setRendered(items)
+      return
+    }
+    setDepartingKeys(new Set(removedItems.map(attachmentKey)))
+    const reduceMotion =
+      typeof window !== 'undefined' && window.matchMedia?.('(prefers-reduced-motion: reduce)').matches
+    const delay = reduceMotion ? 0 : 220
+    const timer = setTimeout(() => {
+      setRendered(items)
+      setDepartingKeys(new Set())
+    }, delay)
+    return () => clearTimeout(timer)
+  }, [items])
+
+  return { rendered: departingKeys.size > 0 ? [...rendered] : items, departingKeys }
+}
+
+export function QueuedAttachmentsList({
+  items,
+  statusOf,
+  onRemove,
+  onRetry,
+  retryingKeys,
+  getThumbnailUrl,
+  labels,
+  busy,
+}: QueuedAttachmentsListProps) {
+  const { rendered, departingKeys } = useDepartingItems(items)
+  if (rendered.length === 0) return null
+
+  const statusLabelOf = (status: AttachmentSendStatus): string => {
+    if (status === 'sending') return labels.sending
+    if (status === 'sent') return labels.sent
+    if (status === 'failed') return labels.failed
+    if (status === 'skipped') return labels.skipped
+    return labels.waiting
+  }
+
+  return (
+    <ul className="cv-workspace-attachments" aria-busy={busy} aria-live="polite">
+      {rendered.map((item) => {
+        const key = attachmentKey(item)
+        const status = statusOf(key)
+        const isDeparting = departingKeys.has(key)
+        return (
+          <li
+            key={key}
+            className={`cv-attachment-item cv-attachment-item--${status}${isDeparting ? ' cv-attachment-item--departing' : ''}`}
+          >
+            <AttachmentThumbnail item={item} getThumbnailUrl={getThumbnailUrl} />
+            <span className="cv-attachment-item__info">
+              <span className="cv-attachment-item__name">{nameOf(item)}</span>
+              <span className="cv-attachment-item__meta">
+                {formatFileSize(sizeOf(item))} · {statusLabelOf(status)}
+              </span>
+            </span>
+            {(status === 'failed' || status === 'skipped') && onRetry ? (
+              <button
+                type="button"
+                className="cv-attachment-item__retry"
+                disabled={busy || (retryingKeys?.has(key) ?? false)}
+                aria-busy={retryingKeys?.has(key) ?? false}
+                onClick={() => onRetry(item)}
+              >
+                {labels.retry}
+              </button>
+            ) : null}
+            <button
+              data-cv-tooltip={labels.remove}
+              type="button"
+              aria-label={labels.remove}
+              disabled={status === 'sending'}
+              onClick={() => onRemove(item)}
+            >
+              ✕
+            </button>
+          </li>
+        )
+      })}
+    </ul>
+  )
+}

package/src/workspace/index.ts

@@ -11,6 +11,7 @@ export { BulkTemplateModal } from './BulkTemplateModal'
 export type { BulkTemplateModalProps } from './BulkTemplateModal'
 export { ConversationsInboxList } from './ConversationsInboxList'
 export type { ConversationsInboxListProps } from './ConversationsInboxList'
+export { QueuedAttachmentsList } from './QueuedAttachmentsList'
 export { useConversationsInbox, CONVERSATIONS_PER_PAGE } from './useConversationsInbox'
 export type { UseConversationsInboxParams, UseConversationsInboxResult } from './useConversationsInbox'
 export { DEFAULT_CONVERSATIONS_WORKSPACE_LABELS } from './labels'

package/src/workspace/labels.ts

@@ -36,6 +36,14 @@ export interface ConversationsWorkspaceLabels {
   readonly attachFailure: string
   /** Tira um arquivo da fila antes de enviar. */
   readonly attachmentRemove: string
+  /** Estado de cada item da fila durante o envio (QR-47). */
+  readonly attachmentWaiting: string
+  readonly attachmentSending: string
+  readonly attachmentSent: string
+  readonly attachmentFailed: string
+  /** Servidor parou antes de tentar este arquivo, por causa de uma falha anterior no mesmo lote. */
+  readonly attachmentSkipped: string
+  readonly attachmentRetry: string
   readonly recordFailure: string
   readonly sendFailure: string
   readonly takeoverToReply: string
@@ -76,6 +84,12 @@ export const DEFAULT_CONVERSATIONS_WORKSPACE_LABELS: ConversationsWorkspaceLabel
   composerPlaceholder: 'Responder como atendente…',
   attachFailure: 'Falha ao enviar o arquivo.',
   attachmentRemove: 'Remover anexo',
+  attachmentWaiting: 'Aguardando',
+  attachmentSending: 'Enviando…',
+  attachmentSent: 'Enviado ✓',
+  attachmentFailed: 'Falhou',
+  attachmentSkipped: 'Não enviado — aguardando o anterior',
+  attachmentRetry: 'Tentar de novo',
   recordFailure: 'Falha ao gravar o áudio.',
   sendFailure: 'Falha ao enviar a mensagem.',
   takeoverToReply: 'Assuma o atendimento para responder diretamente ao cliente.',

package/src/workspace/useComposerAttachmentRetry.ts

@@ -0,0 +1,155 @@
+/**
+ * "Tentar de novo" de um item avulso da fila do composer, extraído de `useComposerQueue`: local
+ * volta por `onSendAttachments` sem legenda (o texto, se havia, já saiu); guardado vai sozinho por
+ * `retryStoredAttachments`, com sua própria chave de idempotência (M3) — nunca a mesma do envio do
+ * rascunho, porque o conjunto de `uploadId` de um retry solo é sempre outro.
+ *
+ * Guarda de troca de conversa (H2): `ConversationPane` fica montado ao trocar de conversa, então um
+ * retry que resolve depois da troca não pode gravar na fila/estado da conversa nova com dado da
+ * antiga. O id da conversa é capturado antes do primeiro `await` e comparado com
+ * `currentConversationIdRef` (espelhado por `useComposerQueue`) depois; troca no meio, o resultado é
+ * descartado. Trava por chave (não a trava global do rascunho) impede duplo clique de reenviar o
+ * mesmo item duas vezes.
+ */
+
+import { useCallback, useRef, useState } from 'react'
+import {
+  attachmentKey,
+  resolveIdempotencyKey,
+  resolveRetryOutcome,
+  retryStoredAttachments,
+  type AttachmentSendStatus,
+  type IdempotencyKeyState,
+} from '../quickReplies/quickReplyAttachments'
+import type { QueuedAttachment } from '../quickReplies/quickReply.types'
+import type { ConversationsApi } from '../providers/types'
+
+export type UseComposerAttachmentRetryParams = {
+  readonly conversationId: string
+  readonly currentConversationIdRef: { readonly current: string }
+  readonly queue: readonly QueuedAttachment[]
+  readonly setQueue: (updater: (current: readonly QueuedAttachment[]) => readonly QueuedAttachment[]) => void
+  readonly setAttachmentStatus: (
+    updater: (current: Record<string, AttachmentSendStatus>) => Record<string, AttachmentSendStatus>,
+  ) => void
+  readonly setSendFailure: (message: string | undefined) => void
+  readonly api: Pick<ConversationsApi, 'sendStoredAttachments'>
+  readonly onSendAttachments?: (files: readonly File[], caption: string) => Promise<void>
+  readonly labels: { readonly attachFailure: string }
+  /** Espelha o envio completo do rascunho (`useComposerQueue`): um retry avulso não pode disparar
+   * enquanto o composer inteiro está em voo — as duas chaves de idempotência colidiriam no mesmo item. */
+  readonly sendInFlightRef: { readonly current: boolean }
+}
+
+export type UseComposerAttachmentRetryResult = {
+  readonly retryQueuedAttachment: (item: QueuedAttachment) => void
+  /** Chamado por `useComposerQueue` ao trocar de conversa: descarta chave de idempotência e travas. */
+  readonly resetRetryState: () => void
+  /** Chaves com retry avulso em voo — `useComposerQueue` exclui estas de um envio completo (evita
+   * duplo envio do mesmo item), e a UI desabilita o botão "Tentar de novo" enquanto durar. */
+  readonly retryingKeys: ReadonlySet<string>
+}
+
+export function useComposerAttachmentRetry(params: UseComposerAttachmentRetryParams): UseComposerAttachmentRetryResult {
+  const {
+    conversationId,
+    currentConversationIdRef,
+    queue,
+    setQueue,
+    setAttachmentStatus,
+    setSendFailure,
+    api,
+    onSendAttachments,
+    labels,
+    sendInFlightRef,
+  } = params
+  const retryIdempotencyKeyRef = useRef<IdempotencyKeyState | undefined>(undefined)
+  /** Chaves com retry em voo — impede duplo clique de reenviar o mesmo item duas vezes. */
+  const retryingKeysRef = useRef<Set<string>>(new Set())
+  /** Espelho reativo de `retryingKeysRef` — o ref sozinho não repinta o botão desabilitado. */
+  const [retryingKeys, setRetryingKeys] = useState<ReadonlySet<string>>(new Set())
+
+  function markRetrying(key: string): void {
+    retryingKeysRef.current.add(key)
+    setRetryingKeys(new Set(retryingKeysRef.current))
+  }
+
+  function unmarkRetrying(key: string): void {
+    retryingKeysRef.current.delete(key)
+    setRetryingKeys(new Set(retryingKeysRef.current))
+  }
+
+  async function retryLocalAttachment(item: Extract<QueuedAttachment, { kind: 'local' }>): Promise<void> {
+    if (!onSendAttachments) return
+    const key = attachmentKey(item)
+    const conversationIdAtRetry = conversationId
+    const isSameConversation = (): boolean => currentConversationIdRef.current === conversationIdAtRetry
+    setAttachmentStatus((current) => ({ ...current, [key]: 'sending' }))
+    try {
+      await onSendAttachments([item.file], '')
+      if (!isSameConversation()) return
+      setAttachmentStatus((current) => ({ ...current, [key]: 'sent' }))
+      setQueue((current) => current.filter((queued) => attachmentKey(queued) !== key))
+    } catch (error: unknown) {
+      if (!isSameConversation()) return
+      setAttachmentStatus((current) => ({ ...current, [key]: 'failed' }))
+      setSendFailure(error instanceof Error ? error.message : labels.attachFailure)
+    }
+  }
+
+  async function retryStoredAttachment(item: Extract<QueuedAttachment, { kind: 'stored' }>): Promise<void> {
+    const sendStoredAttachmentsApi = api.sendStoredAttachments
+    if (!sendStoredAttachmentsApi) return
+    const conversationIdAtRetry = conversationId
+    const isSameConversation = (): boolean => currentConversationIdRef.current === conversationIdAtRetry
+    const uploadIds = [item.uploadId]
+    const idempotencyState = resolveIdempotencyKey(retryIdempotencyKeyRef.current, uploadIds)
+    retryIdempotencyKeyRef.current = idempotencyState
+    try {
+      const result = await retryStoredAttachments({
+        queue,
+        uploadIds,
+        idempotencyKey: idempotencyState.key,
+        sendStoredAttachments: (uploadParams) =>
+          sendStoredAttachmentsApi({ conversationId: conversationIdAtRetry, ...uploadParams }),
+        onAttachmentStatus: (statusKey, status) => {
+          if (isSameConversation()) setAttachmentStatus((current) => ({ ...current, [statusKey]: status }))
+        },
+      })
+      setQueue(
+        (current) =>
+          resolveRetryOutcome({
+            conversationIdAtRetry,
+            currentConversationId: currentConversationIdRef.current,
+            sentAttachmentKeys: result.sentAttachmentKeys,
+            queue: current,
+          }) ?? current,
+      )
+    } catch (error: unknown) {
+      if (isSameConversation()) setSendFailure(error instanceof Error ? error.message : labels.attachFailure)
+    }
+  }
+
+  function retryQueuedAttachment(item: QueuedAttachment): void {
+    // Um envio completo já está em voo — deixá-lo terminar antes de aceitar retry avulso, senão as
+    // duas chaves de idempotência disputam o mesmo item.
+    if (sendInFlightRef.current) return
+    const key = attachmentKey(item)
+    if (retryingKeysRef.current.has(key)) return
+    markRetrying(key)
+    const release = (): void => unmarkRetrying(key)
+    if (item.kind === 'local') {
+      void retryLocalAttachment(item).finally(release)
+      return
+    }
+    void retryStoredAttachment(item).finally(release)
+  }
+
+  const resetRetryState = useCallback((): void => {
+    retryIdempotencyKeyRef.current = undefined
+    retryingKeysRef.current.clear()
+    setRetryingKeys(new Set())
+  }, [])
+
+  return { retryQueuedAttachment, resetRetryState, retryingKeys }
+}

package/src/workspace/useComposerQueue.ts

@@ -0,0 +1,220 @@
+/**
+ * Fila de anexos do composer rico, extraída de `ConversationPane`: texto -> guardados -> locais
+ * (QR-34/QR-43). Reseta tudo ao trocar de conversa (H2).
+ */
+
+import { useCallback, useEffect, useRef, useState } from 'react'
+import {
+  attachmentKey,
+  excludeRetryingItems,
+  resolveIdempotencyKey,
+  sendQueuedMessage,
+  type AttachmentSendStatus,
+  type IdempotencyKeyState,
+} from '../quickReplies/quickReplyAttachments'
+import { useComposerAttachmentRetry } from './useComposerAttachmentRetry'
+import type { QueuedAttachment } from '../quickReplies/quickReply.types'
+import type { ConversationsApi } from '../providers/types'
+
+export type UseComposerQueueParams = {
+  readonly conversationId: string
+  readonly draft: string
+  readonly setDraft: (value: string) => void
+  readonly api: Pick<ConversationsApi, 'sendMessage' | 'sendStoredAttachments'>
+  readonly labels: { readonly sendFailure: string; readonly attachFailure: string }
+  readonly onSendAttachments?: (files: readonly File[], caption: string) => Promise<void>
+  readonly refetch: () => Promise<void>
+  readonly setSendFailure: (message: string | undefined) => void
+}
+
+export type UseComposerQueueResult = {
+  readonly queue: readonly QueuedAttachment[]
+  readonly enqueueAttachments: (items: readonly QueuedAttachment[]) => void
+  readonly attachmentStatus: Record<string, AttachmentSendStatus>
+  readonly isSendingDraft: boolean
+  readonly handleRichSend: () => Promise<void>
+  readonly removeQueuedAttachment: (item: QueuedAttachment) => void
+  readonly retryQueuedAttachment: (item: QueuedAttachment) => void
+  /** Chaves com retry avulso em voo — a UI desabilita o botão "Tentar de novo" desses itens. */
+  readonly retryingKeys: ReadonlySet<string>
+}
+
+export function useComposerQueue(params: UseComposerQueueParams): UseComposerQueueResult {
+  const { conversationId, draft, setDraft, api, labels, onSendAttachments, refetch, setSendFailure } = params
+
+  const [queue, setQueue] = useState<readonly QueuedAttachment[]>([])
+  const [attachmentStatus, setAttachmentStatus] = useState<Record<string, AttachmentSendStatus>>({})
+  const [isSendingDraft, setIsSendingDraft] = useState(false)
+  /** Ref, não estado: entre dois cliques seguidos o React ainda não teria repintado a trava. */
+  const sendInFlightRef = useRef(false)
+  /** Uma por conjunto de `uploadId` guardado em voo (QR-38, M3); muda, `resolveIdempotencyKey` troca. */
+  const idempotencyKeyRef = useRef<IdempotencyKeyState | undefined>(undefined)
+  /** Espelha `conversationId` sem esperar o repaint (H2) — lido depois do `await` de um envio. */
+  const currentConversationIdRef = useRef(conversationId)
+
+  const { retryQueuedAttachment, resetRetryState, retryingKeys } = useComposerAttachmentRetry({
+    conversationId,
+    currentConversationIdRef,
+    queue,
+    setQueue,
+    setAttachmentStatus,
+    setSendFailure,
+    api,
+    labels,
+    sendInFlightRef,
+    ...(onSendAttachments ? { onSendAttachments } : {}),
+  })
+
+  // Trocar de conversa abandona o envio em andamento — senão a resposta tardia reabilitaria o
+  // composer errado ou reusaria a chave de idempotência de outra thread.
+  useEffect(() => {
+    currentConversationIdRef.current = conversationId
+    setQueue([])
+    setAttachmentStatus({})
+    idempotencyKeyRef.current = undefined
+    sendInFlightRef.current = false
+    setIsSendingDraft(false)
+    resetRetryState()
+  }, [conversationId, resetRetryState])
+
+  const enqueueAttachments = useCallback((items: readonly QueuedAttachment[]) => {
+    if (items.length === 0) return
+    setQueue((current) => [...current, ...items])
+  }, [])
+
+  const removeQueuedAttachment = useCallback((item: QueuedAttachment) => {
+    setQueue((current) => current.filter((queued) => attachmentKey(queued) !== attachmentKey(item)))
+  }, [])
+
+  /** Devolve se o envio passou: limpar o rascunho depois de uma falha apagaria o texto do operador. */
+  async function runSend(action: () => Promise<unknown>, fallback: string): Promise<boolean> {
+    setSendFailure(undefined)
+    try {
+      await action()
+      await refetch()
+      return true
+    } catch (error: unknown) {
+      setSendFailure(error instanceof Error ? error.message : fallback)
+      return false
+    }
+  }
+
+  /** Fila só com `local`, como antes da feature de guardados: uma chamada só, rascunho como legenda. */
+  async function sendLocalOnlyAttachments(isSameConversation: () => boolean): Promise<void> {
+    if (!onSendAttachments) return
+    const files = excludeRetryingItems(queue, retryingKeys)
+      .filter((item): item is Extract<QueuedAttachment, { kind: 'local' }> => item.kind === 'local')
+      .map((item) => item.file)
+    try {
+      const didSend = await runSend(() => onSendAttachments(files, draft), labels.attachFailure)
+      if (!isSameConversation()) return
+      if (didSend) {
+        // Preserva item com retry avulso em voo (excluído deste envio) — ele ainda não foi resolvido.
+        setQueue((current) => current.filter((item) => retryingKeys.has(attachmentKey(item))))
+        setAttachmentStatus((current) =>
+          Object.fromEntries(Object.entries(current).filter(([key]) => retryingKeys.has(key))),
+        )
+        idempotencyKeyRef.current = undefined
+        setDraft('')
+      }
+    } finally {
+      if (isSameConversation()) {
+        sendInFlightRef.current = false
+        setIsSendingDraft(false)
+      }
+    }
+  }
+
+  /** Texto -> guardados (lote, um resultado por arquivo) -> locais. Só o que não saiu continua na fila. */
+  async function sendQueuedDraft(isSameConversation: () => boolean): Promise<void> {
+    const sendStoredAttachmentsApi = api.sendStoredAttachments
+    // Item com retry avulso em voo fica de fora deste envio (chave de idempotência diferente) —
+    // senão o servidor recebe o mesmo anexo em dois lotes sem jeito de deduplicar.
+    const sendableQueue = excludeRetryingItems(queue, retryingKeys)
+    const storedUploadIds = sendableQueue
+      .filter((item): item is Extract<QueuedAttachment, { kind: 'stored' }> => item.kind === 'stored')
+      .map((item) => item.uploadId)
+    const idempotencyState = resolveIdempotencyKey(idempotencyKeyRef.current, storedUploadIds)
+    idempotencyKeyRef.current = idempotencyState
+    try {
+      const result = await sendQueuedMessage({
+        text: draft,
+        queue: sendableQueue,
+        idempotencyKey: idempotencyState.key,
+        sendText: (text) => runSend(() => api.sendMessage(conversationId, text), labels.sendFailure),
+        ...(sendStoredAttachmentsApi
+          ? {
+              sendStoredAttachments: (uploadParams: { uploadIds: readonly string[]; idempotencyKey: string }) =>
+                sendStoredAttachmentsApi({ conversationId, ...uploadParams }),
+            }
+          : {}),
+        ...(onSendAttachments
+          ? { sendLocalAttachments: (files: readonly File[]) => onSendAttachments(files, '') }
+          : {}),
+        onAttachmentStatus: (key, status) => {
+          if (isSameConversation()) setAttachmentStatus((current) => ({ ...current, [key]: status }))
+        },
+      })
+      if (!isSameConversation()) return
+      // `runSend` já gravou o erro específico do texto (`setSendFailure`) — não sobrescrever com o
+      // rótulo genérico.
+      if (!result.textSent) return
+      // Filtra por chave sobre a fila CORRENTE, não sobrescreve com `result.remainingQueue` (que foi
+      // calculado sobre a fila capturada antes do `await` e perderia item adicionado durante o envio).
+      const sentKeys = new Set(result.sentAttachmentKeys)
+      // Decide "tudo saiu" sobre a fila CORRENTE dentro do updater, não sobre `result.remainingQueue`
+      // (snapshot de antes do `await` — ficaria obsoleto se algo mudou a fila durante o envio).
+      let queueEmptyAfterSend = false
+      setQueue((current) => {
+        const next = current.filter((item) => !sentKeys.has(attachmentKey(item)))
+        queueEmptyAfterSend = next.length === 0
+        return next
+      })
+      if (queueEmptyAfterSend) {
+        idempotencyKeyRef.current = undefined
+        setAttachmentStatus({})
+      }
+      if (draft.trim()) setDraft('')
+      await refetch()
+    } catch (error: unknown) {
+      if (isSameConversation()) setSendFailure(error instanceof Error ? error.message : labels.attachFailure)
+    } finally {
+      if (isSameConversation()) {
+        sendInFlightRef.current = false
+        setIsSendingDraft(false)
+      }
+    }
+  }
+
+  /** Texto primeiro; se falhar, nenhum anexo sai (QR-34, QR-43). Só o que não saiu continua na fila. */
+  async function handleRichSend(): Promise<void> {
+    // Trava contra clique duplo / Enter impaciente enquanto o upload está em voo.
+    if (sendInFlightRef.current) return
+    if (!draft.trim() && queue.length === 0) return
+    sendInFlightRef.current = true
+    setIsSendingDraft(true)
+    setSendFailure(undefined)
+    // Capturado antes do primeiro `await` (H2) — ver `currentConversationIdRef`.
+    const conversationIdAtSend = conversationId
+    const isSameConversation = (): boolean => currentConversationIdRef.current === conversationIdAtSend
+
+    // QR-32/QR-33: só `stored` (mensagem pronta) vai pelo pipeline novo; só `local` fica no antigo.
+    const hasStoredItems = queue.some((item) => item.kind === 'stored')
+    if (onSendAttachments && queue.length > 0 && !hasStoredItems) {
+      await sendLocalOnlyAttachments(isSameConversation)
+      return
+    }
+    await sendQueuedDraft(isSameConversation)
+  }
+
+  return {
+    queue,
+    enqueueAttachments,
+    attachmentStatus,
+    isSendingDraft,
+    handleRichSend,
+    removeQueuedAttachment,
+    retryQueuedAttachment,
+    retryingKeys,
+  }
+}