@proteos/ui 0.31.0 → 0.32.0

package/src/components/draft-message-composer/draft-message-composer.tsx

@@ -0,0 +1,470 @@
+import type { Conversation, Message, SendRecipient, UpdateDraftRequest } from '@proteos/sdk'
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
+import { Button as AriaButton } from 'react-aria-components'
+import { tv } from 'tailwind-variants'
+
+import { cn } from '../../lib/cn'
+import { Button } from '../button'
+import { type ComposerAttachment, type ComposerValue, MessageComposer } from '../message-composer'
+import { registerDraftMessageActions } from './draft-message-actions-store'
+import { publishDraftMessageOutcome } from './draft-message-outcome-store'
+import type { DraftMessageClient } from './types'
+
+/* =========================================================================
+   DraftMessageComposer — the human-review surface for an agent-drafted
+   outbound message (status=draft). Pass a draft's message id + an injected
+   client (createDraftMessageClient); it loads the draft into the shared
+   MessageComposer, lets the human edit body / subject-on-originate-drafts /
+   recipients-on-email-drafts, then Send (persists dirty edits first) or
+   Reject. Outcomes reach the host three ways: onSent/onRejected callbacks,
+   the keyed outcome store (useDraftMessageOutcome — sibling components), and
+   the actions registry (useDraftMessageActions — external Send/Reject
+   buttons, e.g. a task list's "Execute"; pair with showActions={false}).
+
+   Known v1 limits: attachments are display-only; a `failed` delivery is a
+   terminal surface here (host-side retry = a new send, matching the
+   timeline's failed-retry pattern).
+   ========================================================================= */
+
+export const draftMessageComposerStyles = tv({
+  slots: {
+    root: 'flex flex-col gap-1.5',
+    header: 'flex items-center gap-2 px-[18px] pt-2',
+    badge: [
+      'inline-flex items-center gap-1 rounded-pill border border-rule px-2 py-0.5',
+      'font-mono text-[10px] uppercase tracking-[0.08em] text-ink-3 bg-surface-2',
+    ],
+    sender: 'text-[12.5px] text-ink-3 truncate',
+    actions: 'flex items-center justify-between gap-2 px-[18px] pb-3',
+    terminal: [
+      'mx-[18px] my-3 rounded-[10px] border border-rule bg-surface-2 px-3.5 py-2.5',
+      'text-[12.5px] text-ink-3',
+    ],
+    error: 'px-[18px] font-mono text-[11px] text-danger',
+  },
+})
+
+const styles = draftMessageComposerStyles()
+
+type Phase = 'loading' | 'load-error' | 'ready' | 'terminal'
+type Busy = 'idle' | 'saving' | 'sending' | 'rejecting'
+type TerminalKind = 'sent' | 'rejected' | 'failed' | 'not-draft'
+
+interface DraftSnapshot {
+  text: string
+  subject: string
+  to: SendRecipient[]
+  cc: SendRecipient[]
+  bcc: SendRecipient[]
+}
+
+export interface DraftMessageComposerProps {
+  /** The status=draft message to review. */
+  messageId: string
+  /** Injected fetch surface — see createDraftMessageClient. */
+  client: DraftMessageClient
+  /** Fires once the draft delivered (send resolved pending/sent). */
+  onSent?: (message: Message) => void
+  /** Fires once the draft was declined. */
+  onRejected?: (message: Message) => void
+  /**
+   * Default true. When false the internal Send / Save draft / Reject row is
+   * hidden — the composer becomes a pure preview/edit surface driven by
+   * external controls via useDraftMessageActions.
+   */
+  showActions?: boolean
+  className?: string
+}
+
+/** Maps stored recipient snapshots back to editable send targets (contact
+ *  addresses only; snapshots without an external id cannot be re-addressed). */
+function sendRecipientsFromMessage(message: Message, role: 'to' | 'cc' | 'bcc'): SendRecipient[] {
+  return (message.recipients ?? [])
+    .filter((recipient) => recipient.role === role && !!recipient.external_id)
+    .map((recipient) => ({
+      kind: 'contact-address' as const,
+      external_id: recipient.external_id as string,
+    }))
+}
+
+function terminalKindFor(status: Message['status']): TerminalKind | null {
+  switch (status) {
+    case 'draft':
+      return null
+    case 'pending':
+    case 'sent':
+      return 'sent'
+    case 'rejected':
+      return 'rejected'
+    case 'failed':
+      return 'failed'
+    default:
+      return 'not-draft'
+  }
+}
+
+export function DraftMessageComposer({
+  messageId,
+  client,
+  onSent,
+  onRejected,
+  showActions = true,
+  className,
+}: DraftMessageComposerProps) {
+  const [phase, setPhase] = useState<Phase>('loading')
+  const [busy, setBusy] = useState<Busy>('idle')
+  const [terminalKind, setTerminalKind] = useState<TerminalKind>('not-draft')
+  const [message, setMessage] = useState<Message | null>(null)
+  const [conversation, setConversation] = useState<Conversation | null>(null)
+  const [loadError, setLoadError] = useState<string | null>(null)
+  const [actionError, setActionError] = useState<string | null>(null)
+  const [isConfirmingReject, setIsConfirmingReject] = useState(false)
+  const [value, setValue] = useState<ComposerValue>({ text: '' })
+  const [to, setTo] = useState<SendRecipient[]>([])
+  const [cc, setCc] = useState<SendRecipient[]>([])
+  const [bcc, setBcc] = useState<SendRecipient[]>([])
+  // State (not a ref): isDirty/buildPatch must recompute when a save moves it.
+  const [snapshot, setSnapshot] = useState<DraftSnapshot>({
+    text: '',
+    subject: '',
+    to: [],
+    cc: [],
+    bcc: [],
+  })
+  const [loadNonce, setLoadNonce] = useState(0)
+
+  const isEmail = message?.channel === 'email'
+  const isSubjectEditable = isEmail && conversation?.status === 'draft'
+  const areRecipientsEditable = isEmail && !conversation?.room_id
+
+  const seed = useCallback((draft: Message, thread: Conversation | null) => {
+    const text = draft.content.find((block) => block.type === 'text')?.text ?? ''
+    const subject = thread?.subject ?? ''
+    const seededTo = sendRecipientsFromMessage(draft, 'to')
+    const seededCc = sendRecipientsFromMessage(draft, 'cc')
+    const seededBcc = sendRecipientsFromMessage(draft, 'bcc')
+    setSnapshot({ text, subject, to: seededTo, cc: seededCc, bcc: seededBcc })
+    setValue({ text, ...(draft.channel === 'email' ? { subject } : {}) })
+    setTo(seededTo)
+    setCc(seededCc)
+    setBcc(seededBcc)
+  }, [])
+
+  // Load (and reload on retry): the message, then its conversation.
+  // biome-ignore lint/correctness/useExhaustiveDependencies: loadNonce is the retry trigger — bumping it re-runs the load.
+  useEffect(() => {
+    let isStale = false
+    setPhase('loading')
+    setLoadError(null)
+    setActionError(null)
+    client
+      .getMessage(messageId)
+      .then(async (draft) => {
+        const thread = draft.conversation_id
+          ? await client.getConversation(draft.conversation_id)
+          : null
+        if (isStale) return
+        setMessage(draft)
+        setConversation(thread)
+        const terminal = terminalKindFor(draft.status)
+        if (terminal) {
+          setTerminalKind(terminal)
+          setPhase('terminal')
+          return
+        }
+        seed(draft, thread)
+        setPhase('ready')
+      })
+      .catch((error: unknown) => {
+        if (isStale) return
+        setLoadError(error instanceof Error ? error.message : 'Loading the draft failed')
+        setPhase('load-error')
+      })
+    return () => {
+      isStale = true
+    }
+  }, [client, messageId, seed, loadNonce])
+
+  const isDirty = useMemo(() => {
+    return (
+      value.text !== snapshot.text ||
+      (isSubjectEditable && (value.subject ?? '') !== snapshot.subject) ||
+      JSON.stringify(to) !== JSON.stringify(snapshot.to) ||
+      JSON.stringify(cc) !== JSON.stringify(snapshot.cc) ||
+      JSON.stringify(bcc) !== JSON.stringify(snapshot.bcc)
+    )
+  }, [value, to, cc, bcc, snapshot, isSubjectEditable])
+
+  const buildPatch = useCallback((): UpdateDraftRequest => {
+    const current = message as Message
+    const isBodyEdited = value.text !== snapshot.text
+    const hasRecipientEdit =
+      areRecipientsEditable &&
+      (JSON.stringify(to) !== JSON.stringify(snapshot.to) ||
+        JSON.stringify(cc) !== JSON.stringify(snapshot.cc) ||
+        JSON.stringify(bcc) !== JSON.stringify(snapshot.bcc))
+    const attachmentRefs = (current.attachments ?? []).map((attachment) => attachment.file)
+    return {
+      // Body edits collapse to one text block; an untouched body echoes the
+      // stored blocks so an agent-provided html part survives the edit.
+      content: isBodyEdited
+        ? [{ type: 'text' as const, text: value.text.trim() }]
+        : current.content,
+      ...(isSubjectEditable ? { subject: value.subject ?? '' } : {}),
+      // Presence-based replacement: any recipient edit ships ALL three groups
+      // verbatim — [] is an explicit clear, an omitted group keeps the stored
+      // one. Shipping only non-empty groups would silently resurrect removed
+      // recipients at send time.
+      ...(hasRecipientEdit ? { to, cc, bcc } : {}),
+      ...(attachmentRefs.length > 0 ? { attachments: attachmentRefs } : {}),
+    }
+  }, [message, value, to, cc, bcc, snapshot, areRecipientsEditable, isSubjectEditable])
+
+  const persistDirtyEdits = useCallback(async (): Promise<Message> => {
+    const current = message as Message
+    if (!isDirty) return current
+    const updated = await client.updateDraft(messageId, buildPatch())
+    setMessage(updated)
+    setConversation((thread) =>
+      thread && isSubjectEditable ? { ...thread, subject: value.subject ?? '' } : thread,
+    )
+    setSnapshot({ text: value.text, subject: value.subject ?? '', to, cc, bcc })
+    return updated
+  }, [message, isDirty, client, messageId, buildPatch, isSubjectEditable, value, to, cc, bcc])
+
+  const saveDraft = useCallback(async () => {
+    if (phase !== 'ready' || busy !== 'idle') return
+    setBusy('saving')
+    setActionError(null)
+    try {
+      await persistDirtyEdits()
+    } catch (error) {
+      setActionError(error instanceof Error ? error.message : 'Saving the draft failed')
+    } finally {
+      setBusy('idle')
+    }
+  }, [phase, busy, persistDirtyEdits])
+
+  const send = useCallback(async () => {
+    if (phase !== 'ready' || busy !== 'idle') return
+    // An originate draft addresses people directly — sending it with every
+    // recipient removed can never deliver. (Reply drafts may legitimately go
+    // recipient-less: they deliver into the thread.) Guards the actions
+    // registry too, which bypasses the composer's own canSend gating.
+    if (areRecipientsEditable && conversation?.status === 'draft' && to.length === 0) {
+      setActionError('Add at least one recipient before sending')
+      return
+    }
+    setBusy('sending')
+    setActionError(null)
+    try {
+      await persistDirtyEdits()
+      const result = await client.sendDraft(messageId)
+      setMessage(result)
+      if (result.status === 'failed') {
+        // Delivery failed AFTER the human approved: terminal here, no outcome
+        // published — the timeline's failed-retry pattern owns what's next.
+        setTerminalKind('failed')
+        setPhase('terminal')
+        return
+      }
+      setTerminalKind('sent')
+      setPhase('terminal')
+      publishDraftMessageOutcome(messageId, { type: 'sent', message: result })
+      onSent?.(result)
+    } catch (error) {
+      // Transport/validation failure keeps the edits — the text is the
+      // reviewer's work. Rethrow so the composer's onSend rejects too:
+      // MessageComposer only clears its value on a RESOLVED send.
+      setActionError(error instanceof Error ? error.message : 'Sending the draft failed')
+      throw error
+    } finally {
+      setBusy('idle')
+    }
+  }, [
+    phase,
+    busy,
+    persistDirtyEdits,
+    client,
+    messageId,
+    onSent,
+    areRecipientsEditable,
+    conversation,
+    to,
+  ])
+
+  const reject = useCallback(
+    async (isConfirmed: boolean) => {
+      if (phase !== 'ready' || busy !== 'idle') return
+      if (!isConfirmed) {
+        setIsConfirmingReject(true)
+        return
+      }
+      setBusy('rejecting')
+      setActionError(null)
+      try {
+        // Deliberately ignores dirty edits — declining discards them.
+        const result = await client.rejectDraft(messageId)
+        setMessage(result)
+        setTerminalKind('rejected')
+        setPhase('terminal')
+        publishDraftMessageOutcome(messageId, { type: 'rejected', message: result })
+        onRejected?.(result)
+      } catch (error) {
+        setActionError(error instanceof Error ? error.message : 'Rejecting the draft failed')
+      } finally {
+        setBusy('idle')
+        setIsConfirmingReject(false)
+      }
+    },
+    [phase, busy, client, messageId, onRejected],
+  )
+
+  // Actions registry: external controls (task-list Execute buttons, any
+  // sibling in this realm) drive the mounted composer. Latest-closure refs so
+  // the registered handlers never go stale; re-registered on busy flips so
+  // subscribers see isBusy.
+  const sendRef = useRef(send)
+  const rejectRef = useRef(reject)
+  const saveRef = useRef(saveDraft)
+  sendRef.current = send
+  rejectRef.current = reject
+  saveRef.current = saveDraft
+  useEffect(() => {
+    if (phase !== 'ready') return
+    return registerDraftMessageActions(messageId, {
+      // Failures surface via actionError/outcomes — external drivers get a
+      // settled promise, not a rejection to remember to catch.
+      send: () => sendRef.current().catch(() => undefined),
+      // External UIs own their confirmation — bypass the inline confirm.
+      reject: () => rejectRef.current(true),
+      saveDraft: () => saveRef.current(),
+      isBusy: busy !== 'idle',
+    })
+  }, [messageId, phase, busy])
+
+  const attachments = useMemo<ComposerAttachment[]>(
+    () =>
+      (message?.attachments ?? []).map((attachment) => ({
+        localId: attachment.id,
+        name: attachment.file.name || attachment.file.id,
+        status: 'ready' as const,
+        ...(attachment.file.content_type ? { contentType: attachment.file.content_type } : {}),
+      })),
+    [message?.attachments],
+  )
+
+  if (phase === 'loading') {
+    return (
+      <div className={cn(styles.root(), className)}>
+        <p className={styles.terminal()}>Loading draft…</p>
+      </div>
+    )
+  }
+
+  if (phase === 'load-error') {
+    return (
+      <div className={cn(styles.root(), className)}>
+        <p className={styles.terminal()}>
+          {loadError ?? 'Loading the draft failed.'}{' '}
+          <AriaButton
+            onPress={() => setLoadNonce((nonce) => nonce + 1)}
+            className="inline underline cursor-pointer outline-none focus-visible:shadow-[var(--shadow-focus)]"
+          >
+            retry
+          </AriaButton>
+        </p>
+      </div>
+    )
+  }
+
+  if (phase === 'terminal' || !message) {
+    const line =
+      terminalKind === 'sent'
+        ? 'This draft was sent.'
+        : terminalKind === 'rejected'
+          ? 'This draft was rejected.'
+          : terminalKind === 'failed'
+            ? `Sending failed${message?.error ? ` — ${message.error}` : ''}.`
+            : 'This message is not a reviewable draft.'
+    return (
+      <div className={cn(styles.root(), className)} data-draft-terminal={terminalKind}>
+        <p className={styles.terminal()}>{line}</p>
+      </div>
+    )
+  }
+
+  return (
+    <div className={cn(styles.root(), className)}>
+      <div className={styles.header()}>
+        <span className={styles.badge()}>Draft · awaiting review</span>
+        <span className={styles.sender()}>from {message.sender.name}</span>
+      </div>
+
+      <MessageComposer
+        mode={isEmail ? 'email' : 'chat'}
+        value={value}
+        onValueChange={setValue}
+        placeholder="Draft body…"
+        {...(isEmail && !isSubjectEditable ? { isSubjectReadOnly: true } : {})}
+        onSend={async () => send()}
+        {...(areRecipientsEditable && message.connection_id
+          ? {
+              connectionId: message.connection_id,
+              searchRecipients: client.searchRecipients,
+              showToField: true,
+              showRecipientFields: true,
+              to,
+              cc,
+              bcc,
+              onToChange: setTo,
+              onCcChange: setCc,
+              onBccChange: setBcc,
+            }
+          : {})}
+        {...(attachments.length > 0 ? { attachments } : {})}
+        showSendButton={showActions}
+      />
+
+      {actionError ? <p className={styles.error()}>{actionError} — your edits are kept.</p> : null}
+
+      {showActions ? (
+        <div className={styles.actions()}>
+          {isConfirmingReject ? (
+            <div className="flex items-center gap-2">
+              <span className="text-[12.5px] text-ink-3">Reject draft?</span>
+              <Button
+                size="sm"
+                variant="ghost"
+                onPress={() => void reject(true)}
+                isDisabled={busy !== 'idle'}
+              >
+                Confirm reject
+              </Button>
+              <Button size="sm" variant="subtle" onPress={() => setIsConfirmingReject(false)}>
+                Cancel
+              </Button>
+            </div>
+          ) : (
+            <Button
+              size="sm"
+              variant="ghost"
+              onPress={() => void reject(false)}
+              isDisabled={busy !== 'idle'}
+            >
+              Reject
+            </Button>
+          )}
+          <Button
+            size="sm"
+            variant="subtle"
+            onPress={() => void saveDraft()}
+            isDisabled={busy !== 'idle' || !isDirty}
+          >
+            {busy === 'saving' ? 'Saving…' : 'Save draft'}
+          </Button>
+        </div>
+      ) : null}
+    </div>
+  )
+}

package/src/components/draft-message-composer/draft-message-outcome-store.test.ts

@@ -0,0 +1,59 @@
+import { act, renderHook } from '@testing-library/react'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+import {
+  __resetDraftMessageOutcomes,
+  publishDraftMessageOutcome,
+  subscribeDraftMessageOutcome,
+  useDraftMessageOutcome,
+} from './draft-message-outcome-store'
+import type { DraftMessageOutcome } from './types'
+
+const sentOutcome = (id: string): DraftMessageOutcome => ({
+  type: 'sent',
+  message: { id } as DraftMessageOutcome['message'],
+})
+
+describe('draft-message-outcome-store', () => {
+  beforeEach(() => {
+    __resetDraftMessageOutcomes()
+  })
+
+  it('notifies subscribers of the message id, not others', () => {
+    const onMine = vi.fn()
+    const onOther = vi.fn()
+    subscribeDraftMessageOutcome('m-1', onMine)
+    subscribeDraftMessageOutcome('m-2', onOther)
+
+    publishDraftMessageOutcome('m-1', sentOutcome('m-1'))
+
+    expect(onMine).toHaveBeenCalledTimes(1)
+    expect(onOther).not.toHaveBeenCalled()
+  })
+
+  it('replays the last outcome to a late subscriber', () => {
+    publishDraftMessageOutcome('m-1', sentOutcome('m-1'))
+
+    const { result } = renderHook(() => useDraftMessageOutcome('m-1'))
+    expect(result.current?.type).toBe('sent')
+    expect(result.current?.message.id).toBe('m-1')
+  })
+
+  it('re-renders the hook when the outcome lands', () => {
+    const { result } = renderHook(() => useDraftMessageOutcome('m-9'))
+    expect(result.current).toBeNull()
+
+    act(() => {
+      publishDraftMessageOutcome('m-9', { type: 'rejected', message: { id: 'm-9' } as never })
+    })
+    expect(result.current?.type).toBe('rejected')
+  })
+
+  it('unsubscribes cleanly', () => {
+    const listener = vi.fn()
+    const unsubscribe = subscribeDraftMessageOutcome('m-1', listener)
+    unsubscribe()
+    publishDraftMessageOutcome('m-1', sentOutcome('m-1'))
+    expect(listener).not.toHaveBeenCalled()
+  })
+})

package/src/components/draft-message-composer/draft-message-outcome-store.ts

@@ -0,0 +1,56 @@
+import { useSyncExternalStore } from 'react'
+
+import type { DraftMessageOutcome } from './types'
+
+/* =========================================================================
+   Draft-outcome pub/sub — how SIBLING components learn a draft was sent or
+   rejected without prop drilling (the show-details-store pattern, keyed by
+   message id, plus last-value replay so a subscriber mounting AFTER the
+   outcome still sees it).
+
+   Scope: a per-JS-realm module singleton. In the web app that is the whole
+   page. In the component runtime the import map makes @proteos/ui a
+   singleton PER IFRAME — sibling components inside the SAME custom component
+   share outcomes; separate custom components are separate iframes and do
+   not (cross-iframe reaction stays host-side via query invalidation).
+   ========================================================================= */
+
+const listenersByMessageId = new Map<string, Set<() => void>>()
+const lastOutcomeByMessageId = new Map<string, DraftMessageOutcome>()
+
+export function publishDraftMessageOutcome(messageId: string, outcome: DraftMessageOutcome): void {
+  lastOutcomeByMessageId.set(messageId, outcome)
+  for (const listener of listenersByMessageId.get(messageId) ?? []) listener()
+}
+
+export function subscribeDraftMessageOutcome(messageId: string, listener: () => void): () => void {
+  let listeners = listenersByMessageId.get(messageId)
+  if (!listeners) {
+    listeners = new Set()
+    listenersByMessageId.set(messageId, listeners)
+  }
+  listeners.add(listener)
+  return () => {
+    listeners.delete(listener)
+    if (listeners.size === 0) listenersByMessageId.delete(messageId)
+  }
+}
+
+/**
+ * The last outcome for this draft, or null while it is still under review.
+ * Re-renders when the outcome lands — including for subscribers that mounted
+ * after it (last-value replay).
+ */
+export function useDraftMessageOutcome(messageId: string): DraftMessageOutcome | null {
+  return useSyncExternalStore(
+    (listener) => subscribeDraftMessageOutcome(messageId, listener),
+    () => lastOutcomeByMessageId.get(messageId) ?? null,
+    () => null,
+  )
+}
+
+/** Test-only escape hatch — clears every stored outcome and listener. */
+export function __resetDraftMessageOutcomes(): void {
+  listenersByMessageId.clear()
+  lastOutcomeByMessageId.clear()
+}

package/src/components/draft-message-composer/index.ts

@@ -0,0 +1,19 @@
+export { createDraftMessageClient } from './create-draft-message-client'
+export {
+  __resetDraftMessageActions,
+  type DraftMessageActions,
+  registerDraftMessageActions,
+  useDraftMessageActions,
+} from './draft-message-actions-store'
+export {
+  DraftMessageComposer,
+  type DraftMessageComposerProps,
+  draftMessageComposerStyles,
+} from './draft-message-composer'
+export {
+  __resetDraftMessageOutcomes,
+  publishDraftMessageOutcome,
+  subscribeDraftMessageOutcome,
+  useDraftMessageOutcome,
+} from './draft-message-outcome-store'
+export type { DraftMessageClient, DraftMessageOutcome } from './types'

package/src/components/draft-message-composer/types.ts

@@ -0,0 +1,32 @@
+import type { ContactAddress, Conversation, Message, UpdateDraftRequest } from '@proteos/sdk'
+
+/* =========================================================================
+   DraftMessageComposer contracts — types-only @proteos/sdk imports, so the
+   lib stays fetch-agnostic (the data-table InfiniteQueryLike precedent): the
+   host injects the client, the component never talks to the network itself.
+   ========================================================================= */
+
+/**
+ * The minimal fetch surface DraftMessageComposer needs, injected per host:
+ * the web app builds it from `useSdk().conversation`, custom components from
+ * `useSdk().conversations` — both via {@link createDraftMessageClient}.
+ */
+export interface DraftMessageClient {
+  /** One message with projections — also resolves terminal states by id. */
+  getMessage(messageId: string): Promise<Message>
+  /** The draft's conversation: subject, status (draft ⇒ subject editable), room. */
+  getConversation(conversationId: string): Promise<Conversation>
+  /** Full-replacement draft edit (PUT semantics — send the complete state). */
+  updateDraft(messageId: string, patch: UpdateDraftRequest): Promise<Message>
+  /** Deliver the draft (draft → pending → sent/failed). 409 on a lost race. */
+  sendDraft(messageId: string): Promise<Message>
+  /** Decline the draft (draft → rejected, terminal). 409 on a lost race. */
+  rejectDraft(messageId: string): Promise<Message>
+  /** Directory search backing the To/Cc/Bcc pickers (email drafts only). */
+  searchRecipients(connectionId: string, q: string): Promise<ContactAddress[]>
+}
+
+/** What happened to a reviewed draft — the payload of the outcome store. */
+export type DraftMessageOutcome =
+  | { type: 'sent'; message: Message }
+  | { type: 'rejected'; message: Message }

package/src/components/message-composer/index.ts

@@ -0,0 +1,13 @@
+export type {
+  ComposerAttachment,
+  ComposerConnectionPicker,
+  ComposerSendInput,
+  ComposerValue,
+  MessageComposerProps,
+  SearchRecipients,
+} from './message-composer'
+export {
+  MAX_COMPOSER_ATTACHMENT_BYTES,
+  MessageComposer,
+  messageComposerStyles,
+} from './message-composer'