@adatechnology/conversations-ui 0.6.0 → 0.7.0

package/src/participant/participantMessageAtoms.ts

@@ -0,0 +1,53 @@
+import { findCopyableAtoms } from './participantMessageCopyables'
+import type { InlineAtom } from './participantMessageFormat.types'
+import { findLinkAtoms } from './participantMessageLinks'
+
+const TRIPLE_FENCE = '```'
+
+function spanAt(
+  text: string,
+  open: number,
+): { readonly contentStart: number; readonly close: number; readonly width: number } | undefined {
+  const isTriple = text.startsWith(TRIPLE_FENCE, open)
+  const width = isTriple ? 3 : 1
+  const close = text.indexOf(isTriple ? TRIPLE_FENCE : '`', open + width)
+  if (close === -1) return undefined
+  return { contentStart: open + width, close, width }
+}
+
+export function findCodeAtoms(text: string): InlineAtom[] {
+  const atoms: InlineAtom[] = []
+  let cursor = text.indexOf('`')
+  while (cursor !== -1) {
+    const span = spanAt(text, cursor)
+    if (span === undefined) {
+      if (!text.startsWith(TRIPLE_FENCE, cursor)) break
+      cursor = text.indexOf('`', cursor + 3)
+      continue
+    }
+    if (span.close === span.contentStart) {
+      cursor = text.indexOf('`', cursor + span.width)
+      continue
+    }
+    const end = span.close + span.width
+    atoms.push({ start: cursor, end, node: { kind: 'code', value: text.slice(span.contentStart, span.close) } })
+    cursor = text.indexOf('`', end)
+  }
+  return atoms
+}
+
+/** Code wins over links, links over copyable tokens; overlapping losers are dropped. */
+export function findInlineAtoms(text: string): InlineAtom[] {
+  const candidates = [...findCodeAtoms(text), ...findLinkAtoms(text), ...findCopyableAtoms(text)]
+  const ordered = candidates
+    .map((atom, rank) => ({ atom, rank }))
+    .sort((a, b) => a.atom.start - b.atom.start || a.rank - b.rank)
+  const accepted: InlineAtom[] = []
+  let lastEnd = 0
+  for (const { atom } of ordered) {
+    if (atom.start < lastEnd) continue
+    accepted.push(atom)
+    lastEnd = atom.end
+  }
+  return accepted
+}

package/src/participant/participantMessageCopyables.test.ts

@@ -0,0 +1,141 @@
+import { describe, expect, it } from 'bun:test'
+
+import { isValidCnpj, isValidCpf } from './participantDocuments'
+import { show } from './participantMessageFormat.test-helper'
+import { parseInline } from './participantMessageInline'
+
+function inline(line: string): string {
+  return show(parseInline(line))
+}
+
+function copyable(kind: string, value: string): string {
+  return `⟦k:${kind}:${value}⟧`
+}
+
+describe('check digits', () => {
+  it('validates CPF', () => {
+    expect(isValidCpf('52998224725')).toBe(true)
+    expect(isValidCpf('52998224726')).toBe(false)
+    expect(isValidCpf('11111111111')).toBe(false)
+    expect(isValidCpf('1234567890')).toBe(false)
+  })
+
+  it('validates numeric and alphanumeric CNPJ', () => {
+    expect(isValidCnpj('11222333000181')).toBe(true)
+    expect(isValidCnpj('11222333000182')).toBe(false)
+    expect(isValidCnpj('12ABC34501DE35')).toBe(true)
+    expect(isValidCnpj('12ABC34501DE36')).toBe(false)
+    expect(isValidCnpj('00000000000000')).toBe(false)
+  })
+})
+
+describe('copyable - CPF', () => {
+  it('detects valid CPF with and without mask', () => {
+    expect(inline('CPF 529.982.247-25 ok')).toBe(`CPF ${copyable('cpf', '529.982.247-25')} ok`)
+    expect(inline('52998224725')).toBe(copyable('cpf', '52998224725'))
+    expect(inline('CPF: 529.982.247-25.')).toBe(`CPF: ${copyable('cpf', '529.982.247-25')}.`)
+  })
+
+  it('ignores repeated sequences and wrong check digits', () => {
+    expect(inline('111.111.111-11')).toBe('111.111.111-11')
+    expect(inline('11111111111')).toBe('11111111111')
+    expect(inline('529.982.247-26')).toBe('529.982.247-26')
+  })
+})
+
+describe('copyable - CNPJ', () => {
+  it('detects valid numeric CNPJ with and without mask', () => {
+    expect(inline('11.222.333/0001-81')).toBe(copyable('cnpj', '11.222.333/0001-81'))
+    expect(inline('11222333000181')).toBe(copyable('cnpj', '11222333000181'))
+  })
+
+  it('detects the new alphanumeric CNPJ', () => {
+    expect(inline('12.ABC.345/01DE-35')).toBe(copyable('cnpj', '12.ABC.345/01DE-35'))
+    expect(inline('12ABC34501DE35')).toBe(copyable('cnpj', '12ABC34501DE35'))
+  })
+
+  it('ignores invalid CNPJ and does not take it for a phone', () => {
+    expect(inline('11.222.333/0001-82')).toBe('11.222.333/0001-82')
+    expect(inline('12ABC34501DE36')).toBe('12ABC34501DE36')
+  })
+})
+
+describe('copyable - access key', () => {
+  const KEY = '35260112345678000195550010000012341000012345'
+
+  it('detects exactly 44 digits, bare or in groups of four', () => {
+    expect(KEY).toHaveLength(44)
+    expect(inline(`chave ${KEY}`)).toBe(`chave ${copyable('accessKey', KEY)}`)
+    const grouped = KEY.match(/\d{4}/g)?.join(' ') ?? ''
+    expect(inline(grouped)).toBe(copyable('accessKey', grouped))
+  })
+
+  it('ignores 43 and 45 digit runs', () => {
+    expect(inline(KEY.slice(1))).toBe(KEY.slice(1))
+    expect(inline(`${KEY}1`)).toBe(`${KEY}1`)
+  })
+
+  it('ignores a repeated sequence', () => {
+    expect(inline('1'.repeat(44))).toBe('1'.repeat(44))
+  })
+})
+
+describe('copyable - phone', () => {
+  it('detects five formats and keeps the mask as typed', () => {
+    expect(inline('(16) 99999-0000')).toBe(copyable('phone', '(16) 99999-0000'))
+    expect(inline('+55 16 99999-0000')).toBe(copyable('phone', '+55 16 99999-0000'))
+    expect(inline('16 99999-0000')).toBe(copyable('phone', '16 99999-0000'))
+    expect(inline('(16) 3333-4444')).toBe(copyable('phone', '(16) 3333-4444'))
+    expect(inline('+1 415 555 2671')).toBe(copyable('phone', '+1 415 555 2671'))
+  })
+
+  it('does not take bare 10 or 11 digits for a phone', () => {
+    expect(inline('pedido 1234567890')).toBe('pedido 1234567890')
+    expect(inline('16999990000')).toBe('16999990000')
+    expect(inline('1633334444')).toBe('1633334444')
+  })
+
+  it('accepts a bare number only with +55, a bracketed DDD or a separator after the DDD', () => {
+    expect(inline('+5516999990000')).toBe(copyable('phone', '+5516999990000'))
+    expect(inline('(16)999990000')).toBe(copyable('phone', '(16)999990000'))
+    expect(inline('16-999990000')).toBe(copyable('phone', '16-999990000'))
+  })
+
+  it('keeps the final dot outside', () => {
+    expect(inline('ligue (16) 99999-0000.')).toBe(`ligue ${copyable('phone', '(16) 99999-0000')}.`)
+  })
+})
+
+describe('copyable - e-mail', () => {
+  it('detects e-mail addresses', () => {
+    expect(inline('fale a@b.co.')).toBe(`fale ${copyable('email', 'a@b.co')}.`)
+    expect(inline('ana.souza+x@mail.example.com.br')).toBe(copyable('email', 'ana.souza+x@mail.example.com.br'))
+  })
+
+  it('ignores malformed addresses', () => {
+    expect(inline('@ana')).toBe('@ana')
+    expect(inline('a@b')).toBe('a@b')
+    expect(inline('a@.co')).toBe('a@.co')
+  })
+})
+
+describe('copyable - false positives avoided', () => {
+  it('does not highlight money, dates, short numbers or labels', () => {
+    expect(inline('R$ 1.234,56')).toBe('R$ 1.234,56')
+    expect(inline('10/10/2026')).toBe('10/10/2026')
+    expect(inline('2026-10-01')).toBe('2026-10-01')
+    expect(inline('12345')).toBe('12345')
+    expect(inline('NF 4521')).toBe('NF 4521')
+    expect(inline('total 1234567')).toBe('total 1234567')
+  })
+
+  it('does not detect inside inline code or inside a URL', () => {
+    expect(inline('`529.982.247-25`')).toBe('⟦c:529.982.247-25⟧')
+    expect(inline('`a@b.co`')).toBe('⟦c:a@b.co⟧')
+    expect(inline('https://a.com/52998224725')).toBe('⟦l:https://a.com/52998224725→https://a.com/52998224725⟧')
+  })
+
+  it('lets a mark wrap a token', () => {
+    expect(inline('*529.982.247-25*')).toBe(`⟦s:${copyable('cpf', '529.982.247-25')}⟧`)
+  })
+})

package/src/participant/participantMessageCopyables.ts

@@ -0,0 +1,76 @@
+import { isValidCnpj, isValidCpf } from './participantDocuments'
+import type { CopyableKind, InlineAtom } from './participantMessageFormat.types'
+
+type Scanner = { readonly copyKind: CopyableKind; readonly pattern: RegExp; readonly isValid: (raw: string) => boolean }
+
+const DOCUMENT_SEPARATORS = /[.\-/\s]/g
+const ACCESS_KEY_PATTERN = /\d{44}|\d{4}(?: \d{4}){10}/gu
+const CNPJ_PATTERN = /[A-Z0-9]{2}\.[A-Z0-9]{3}\.[A-Z0-9]{3}\/[A-Z0-9]{4}-\d{2}|[A-Z0-9]{12}\d{2}/gu
+const CPF_PATTERN = /\d{3}\.\d{3}\.\d{3}-\d{2}|\d{11}/gu
+const BRAZIL_PHONE_PATTERN = /(?:\+?55[\s.-]?)?(?:\([1-9][1-9]\)|[1-9][1-9])[\s.-]?(?:9\d{4}|[2-5]\d{3})[\s.-]?\d{4}/gu
+const INTERNATIONAL_PHONE_PATTERN = /\+\d{1,3}(?:[\s.-]?\d{2,5}){2,4}/gu
+const EMAIL_LOCAL = /^[\p{L}\p{N}._%+-]+$/u
+const EMAIL_DOMAIN = /^[\p{L}\p{N}-]+(?:\.[\p{L}\p{N}-]+)*\.\p{L}{2,}$/u
+
+function bare(raw: string): string {
+  return raw.replace(DOCUMENT_SEPARATORS, '')
+}
+
+function isWordCharacter(character: string | undefined): boolean {
+  return character !== undefined && /[\p{L}\p{N}]/u.test(character)
+}
+
+function hasPhoneDigitCount(raw: string): boolean {
+  const count = raw.replace(/\D/g, '').length
+  return count >= 10 && count <= 15
+}
+
+/** Bare 10/11 digits are order numbers as often as phones: demand +country, a bracketed DDD or a separator after it. */
+function isFormattedBrazilPhone(raw: string): boolean {
+  return /^\+|\(|^\d{2}[\s.-]/u.test(raw) && hasPhoneDigitCount(raw)
+}
+
+const SCANNERS: readonly Scanner[] = [
+  { copyKind: 'accessKey', pattern: ACCESS_KEY_PATTERN, isValid: (raw) => !/^(\d)\1+$/.test(bare(raw)) },
+  { copyKind: 'cnpj', pattern: CNPJ_PATTERN, isValid: (raw) => isValidCnpj(bare(raw)) },
+  { copyKind: 'cpf', pattern: CPF_PATTERN, isValid: (raw) => isValidCpf(bare(raw)) },
+  { copyKind: 'phone', pattern: BRAZIL_PHONE_PATTERN, isValid: isFormattedBrazilPhone },
+  {
+    copyKind: 'phone',
+    pattern: INTERNATIONAL_PHONE_PATTERN,
+    isValid: (raw) => hasPhoneDigitCount(raw) && !raw.startsWith('+55'),
+  },
+]
+
+function scan(text: string, scanner: Scanner): InlineAtom[] {
+  const atoms: InlineAtom[] = []
+  for (const match of text.matchAll(scanner.pattern)) {
+    const [value] = match
+    const start = match.index
+    const end = start + value.length
+    if (isWordCharacter(text[start - 1]) || isWordCharacter(text[end])) continue
+    if (!scanner.isValid(value)) continue
+    atoms.push({ start, end, node: { kind: 'copyable', copyKind: scanner.copyKind, value } })
+  }
+  return atoms
+}
+
+function findEmailAtoms(text: string): InlineAtom[] {
+  const atoms: InlineAtom[] = []
+  for (let at = text.indexOf('@'); at !== -1; at = text.indexOf('@', at + 1)) {
+    let start = at
+    while (start > 0 && /[\p{L}\p{N}._%+-]/u.test(text[start - 1] ?? '')) start -= 1
+    let end = at + 1
+    while (end < text.length && /[\p{L}\p{N}.-]/u.test(text[end] ?? '')) end += 1
+    while (end > at + 1 && /[.-]/.test(text[end - 1] ?? '')) end -= 1
+    const isValid = EMAIL_LOCAL.test(text.slice(start, at)) && EMAIL_DOMAIN.test(text.slice(at + 1, end))
+    if (isValid) {
+      atoms.push({ start, end, node: { kind: 'copyable', copyKind: 'email', value: text.slice(start, end) } })
+    }
+  }
+  return atoms
+}
+
+export function findCopyableAtoms(text: string): InlineAtom[] {
+  return [...SCANNERS.flatMap((scanner) => scan(text, scanner)), ...findEmailAtoms(text)]
+}

package/src/participant/participantMessageFormat.test-helper.ts

@@ -0,0 +1,21 @@
+import type { InlineNode } from './participantMessageFormat.types'
+
+/** Compact notation to make the case tables readable: s=strong, e=em, d=del, c=code, l=link, t=text. */
+export function show(nodes: readonly InlineNode[]): string {
+  return nodes.map(showNode).join('')
+}
+
+function showNode(node: InlineNode): string {
+  switch (node.kind) {
+    case 'text':
+      return node.value
+    case 'code':
+      return `⟦c:${node.value}⟧`
+    case 'copyable':
+      return `⟦k:${node.copyKind}:${node.value}⟧`
+    case 'link':
+      return `⟦l:${node.label}→${node.href}⟧`
+    default:
+      return `⟦${node.kind[0]}:${show(node.children)}⟧`
+  }
+}

package/src/participant/participantMessageFormat.test.ts

@@ -0,0 +1,177 @@
+import { describe, expect, it } from 'bun:test'
+
+import { MAX_FORMATTED_LENGTH, parseParticipantMessage } from './participantMessageFormat'
+import { show } from './participantMessageFormat.test-helper'
+import type { FormatBlock } from './participantMessageFormat.types'
+
+function showBlock(block: FormatBlock): string {
+  if (block.kind === 'paragraph') return `P[${show(block.children)}]`
+  if (block.kind === 'pre') return `PRE[${block.value}]`
+  if (block.kind === 'quote') return `Q[${show(block.children)}]`
+  const tag = block.ordered ? `OL${block.start}` : 'UL'
+  return `${tag}[${block.items.map(show).join('|')}]`
+}
+
+function blocks(text: string | null | undefined): string {
+  return parseParticipantMessage(text).map(showBlock).join(' ')
+}
+
+describe('parseParticipantMessage - input', () => {
+  it('returns no blocks for empty, blank or missing input', () => {
+    expect(blocks('')).toBe('')
+    expect(blocks('   ')).toBe('')
+    expect(blocks('\n \n')).toBe('')
+    expect(blocks(null)).toBe('')
+    expect(blocks(undefined)).toBe('')
+  })
+
+  it('keeps plain text as one paragraph with one text node', () => {
+    expect(parseParticipantMessage('Olá, tudo bem?')).toEqual([
+      { kind: 'paragraph', children: [{ kind: 'text', value: 'Olá, tudo bem?' }] },
+    ])
+  })
+
+  it('preserves typed line breaks, including blank lines', () => {
+    expect(blocks('a\nb')).toBe('P[a\nb]')
+    expect(blocks('a\n\nb')).toBe('P[a\n\nb]')
+    expect(blocks('a\r\nb')).toBe('P[a\nb]')
+  })
+
+  it('formats each line on its own: marks never cross a line break', () => {
+    expect(blocks('*a\nb*')).toBe('P[*a\nb*]')
+    expect(blocks('*a*\n_b_')).toBe('P[⟦s:a⟧\n⟦e:b⟧]')
+  })
+})
+
+describe('parseParticipantMessage - size limit', () => {
+  it('formats up to the limit', () => {
+    const text = `*a*${' '.repeat(MAX_FORMATTED_LENGTH - 3)}`
+    expect(text).toHaveLength(MAX_FORMATTED_LENGTH)
+    expect(blocks(text).startsWith('P[⟦s:a⟧')).toBe(true)
+  })
+
+  it('treats anything above the limit as one plain text node', () => {
+    const text = `*a* https://a.com\n> b\n${'x'.repeat(MAX_FORMATTED_LENGTH)}`
+    expect(parseParticipantMessage(text)).toEqual([{ kind: 'paragraph', children: [{ kind: 'text', value: text }] }])
+    const justOver = `*a*${' '.repeat(MAX_FORMATTED_LENGTH - 2)}`
+    expect(justOver).toHaveLength(MAX_FORMATTED_LENGTH + 1)
+    expect(parseParticipantMessage(justOver)).toHaveLength(1)
+    expect(blocks(justOver)).not.toContain('⟦s:')
+  })
+})
+
+describe('parseParticipantMessage - code blocks', () => {
+  it('parses a multi-line block without a stray blank line', () => {
+    expect(blocks('```\nconst a = 1\nconst b = 2\n```')).toBe('PRE[const a = 1\nconst b = 2]')
+  })
+
+  it('parses a single-line block and one that shares the fence lines', () => {
+    expect(blocks('```x *y*```')).toBe('PRE[x *y*]')
+    expect(blocks('```a\nb```')).toBe('PRE[a\nb]')
+    expect(blocks('```js\nconst a = 1\n```')).toBe('PRE[const a = 1]')
+    expect(blocks('```two words\nx\n```')).toBe('PRE[two words\nx]')
+  })
+
+  it('keeps inner blank lines and never formats inside', () => {
+    expect(blocks('```\n*a*\n\n_b_ https://a.com 529.982.247-25\n```')).toBe(
+      'PRE[*a*\n\n_b_ https://a.com 529.982.247-25]',
+    )
+  })
+
+  it('keeps text around the block as paragraphs', () => {
+    expect(blocks('antes\n```\nx\n```\ndepois')).toBe('P[antes] PRE[x] P[depois]')
+  })
+
+  it('treats an unclosed fence as plain text', () => {
+    expect(blocks('```\nabc')).toBe('P[```\nabc]')
+  })
+})
+
+describe('parseParticipantMessage - quotes', () => {
+  it('turns consecutive quote lines into one block', () => {
+    expect(blocks('> a\n> b')).toBe('Q[a\nb]')
+    expect(blocks('> a\n> b\nc')).toBe('Q[a\nb] P[c]')
+  })
+
+  it('formats inline marks inside the quote', () => {
+    expect(blocks('> *a* e _b_')).toBe('Q[⟦s:a⟧ e ⟦e:b⟧]')
+  })
+
+  it('needs the space after the marker and the marker at the start of the line', () => {
+    expect(blocks('>a')).toBe('P[>a]')
+    expect(blocks('a > b')).toBe('P[a > b]')
+  })
+
+  it('splits two quotes separated by a normal line', () => {
+    expect(blocks('> a\nx\n> b')).toBe('Q[a] P[x] Q[b]')
+  })
+})
+
+describe('parseParticipantMessage - lists', () => {
+  it('parses bullet lists with the three markers', () => {
+    expect(blocks('- a\n- b')).toBe('UL[a|b]')
+    expect(blocks('* a\n* b')).toBe('UL[a|b]')
+    expect(blocks('• a\n• b')).toBe('UL[a|b]')
+  })
+
+  it('requires the space after the marker', () => {
+    expect(blocks('-a')).toBe('P[-a]')
+    expect(blocks('*a*')).toBe('P[⟦s:a⟧]')
+    expect(blocks('•a')).toBe('P[•a]')
+    expect(blocks('- ')).toBe('P[- ]')
+  })
+
+  it('parses numbered lists with dot or parenthesis and keeps the first number', () => {
+    expect(blocks('1. a\n2. b')).toBe('OL1[a|b]')
+    expect(blocks('1) a\n2) b')).toBe('OL1[a|b]')
+    expect(blocks('3. a\n4. b')).toBe('OL3[a|b]')
+    expect(blocks('1.a')).toBe('P[1.a]')
+  })
+
+  it('formats inline marks inside items', () => {
+    expect(blocks('- *a*\n- _b_ https://a.com')).toBe('UL[⟦s:a⟧|⟦e:b⟧ ⟦l:https://a.com→https://a.com⟧]')
+  })
+
+  it('splits different list kinds and keeps surrounding text', () => {
+    expect(blocks('- a\n1. b')).toBe('UL[a] OL1[b]')
+    expect(blocks('título\n- a\n- b\nfim')).toBe('P[título] UL[a|b] P[fim]')
+  })
+
+  it('does not take a sentence with a number as a list', () => {
+    expect(blocks('2 * 3 * 4')).toBe('P[2 * 3 * 4]')
+    expect(blocks('2026. foi bom')).toBe('P[2026. foi bom]')
+  })
+})
+
+describe('parseParticipantMessage - emoji', () => {
+  it('does not touch ZWJ sequences, flags, skin tones or variation selectors', () => {
+    const text = '👨‍👩‍👧 🇧🇷 👍🏽 ‼️'
+    expect(parseParticipantMessage(text)).toEqual([{ kind: 'paragraph', children: [{ kind: 'text', value: text }] }])
+    expect(blocks('- 👨‍👩‍👧\n- 🇧🇷')).toBe('UL[👨‍👩‍👧|🇧🇷]')
+  })
+})
+
+describe('parseParticipantMessage - pathological input', () => {
+  const CASES: readonly (readonly [string, string])[] = [
+    ['alternating marks', '*_'.repeat(4000)],
+    ['open brackets', '['.repeat(8000)],
+    ['unmatched openers', '*a '.repeat(2666)],
+    ['backticks', '`'.repeat(8000)],
+    ['mixed marks', '~_*'.repeat(2666)],
+    ['at signs', 'a@'.repeat(4000)],
+    ['schemes', 'http://'.repeat(1100)],
+    ['digits', '1'.repeat(8000)],
+    ['many lines', '> *a\n- _b\n'.repeat(800)],
+    ['fences', '```\n'.repeat(1600)],
+  ]
+
+  it('parses the worst cases under 50ms each', () => {
+    for (const [name, input] of CASES) {
+      parseParticipantMessage(input.slice(0, 200))
+      const startedAt = performance.now()
+      parseParticipantMessage(input.slice(0, 8000))
+      const elapsed = performance.now() - startedAt
+      expect({ name, fast: elapsed < 50 }).toEqual({ name, fast: true })
+    }
+  })
+})

package/src/participant/participantMessageFormat.ts

@@ -0,0 +1,135 @@
+import type { FormatBlock, InlineNode } from './participantMessageFormat.types'
+import { parseInline } from './participantMessageInline'
+
+/** Above this size the text is shown as typed: formatting is a courtesy, not a cost. */
+export const MAX_FORMATTED_LENGTH = 8000
+
+const FENCE = '```'
+const LANGUAGE_LABEL = /^[a-z][a-z0-9+#.-]{0,19}$/i
+const QUOTE_PREFIX = /^> /
+const BULLET_PREFIX = /^[-*•] +(?=\S)/
+const ORDERED_PREFIX = /^(\d{1,3})[.)] +(?=\S)/
+
+type ListBlock = Extract<FormatBlock, { kind: 'list' }>
+
+function joinLines(lines: readonly string[]): InlineNode[] {
+  const nodes: InlineNode[] = []
+  lines.forEach((line, index) => {
+    if (index > 0) nodes.push({ kind: 'text', value: '\n' })
+    nodes.push(...parseInline(line))
+  })
+  return mergeText(nodes)
+}
+
+function mergeText(nodes: readonly InlineNode[]): InlineNode[] {
+  const merged: InlineNode[] = []
+  for (const node of nodes) {
+    const previous = merged[merged.length - 1]
+    if (node.kind === 'text' && previous?.kind === 'text') {
+      merged[merged.length - 1] = { kind: 'text', value: previous.value + node.value }
+    } else {
+      merged.push(node)
+    }
+  }
+  return merged
+}
+
+function plainParagraph(text: string): FormatBlock[] {
+  return [{ kind: 'paragraph', children: [{ kind: 'text', value: text }] }]
+}
+
+type Fence = { readonly value: string; readonly nextIndex: number }
+
+function readFence(lines: readonly string[], index: number): Fence | undefined {
+  const first = (lines[index] ?? '').trimStart()
+  if (!first.startsWith(FENCE)) return undefined
+  const inner = first.slice(FENCE.length)
+  if (inner.trimEnd().endsWith(FENCE) && inner.trim() !== FENCE) {
+    return { value: inner.trimEnd().slice(0, -FENCE.length), nextIndex: index + 1 }
+  }
+  const hasLabel = LANGUAGE_LABEL.test(inner.trim())
+  const body: string[] = inner === '' || hasLabel ? [] : [inner]
+  for (let cursor = index + 1; cursor < lines.length; cursor += 1) {
+    const line = (lines[cursor] ?? '').trimEnd()
+    if (!line.endsWith(FENCE)) {
+      body.push(line)
+      continue
+    }
+    const last = line.slice(0, -FENCE.length)
+    if (last !== '') body.push(last)
+    if (last !== '' && hasLabel && body.length === 1) body.unshift(inner)
+    return { value: body.join('\n'), nextIndex: cursor + 1 }
+  }
+  return undefined
+}
+
+function startsSpecialBlock(line: string): boolean {
+  const trimmed = line.trimStart()
+  return trimmed.startsWith(FENCE) || QUOTE_PREFIX.test(line) || BULLET_PREFIX.test(line) || ORDERED_PREFIX.test(line)
+}
+
+function readQuote(lines: readonly string[], index: number): { block: FormatBlock; nextIndex: number } {
+  const quoted: string[] = []
+  let cursor = index
+  while (cursor < lines.length && QUOTE_PREFIX.test(lines[cursor] ?? '')) {
+    quoted.push((lines[cursor] ?? '').slice(2))
+    cursor += 1
+  }
+  return { block: { kind: 'quote', children: joinLines(quoted) }, nextIndex: cursor }
+}
+
+function readList(lines: readonly string[], index: number): { block: ListBlock; nextIndex: number } {
+  const ordered = ORDERED_PREFIX.test(lines[index] ?? '')
+  const prefix = ordered ? ORDERED_PREFIX : BULLET_PREFIX
+  const start = ordered ? Number(ORDERED_PREFIX.exec(lines[index] ?? '')?.[1] ?? 1) : 1
+  const items: InlineNode[][] = []
+  let cursor = index
+  while (cursor < lines.length && prefix.test(lines[cursor] ?? '')) {
+    items.push(parseInline((lines[cursor] ?? '').replace(prefix, '')))
+    cursor += 1
+  }
+  return { block: { kind: 'list', ordered, start, items }, nextIndex: cursor }
+}
+
+function readParagraph(lines: readonly string[], index: number): { block: FormatBlock; nextIndex: number } {
+  const collected: string[] = [lines[index] ?? '']
+  let cursor = index + 1
+  while (cursor < lines.length && !startsSpecialBlock(lines[cursor] ?? '')) {
+    collected.push(lines[cursor] ?? '')
+    cursor += 1
+  }
+  return { block: { kind: 'paragraph', children: joinLines(collected) }, nextIndex: cursor }
+}
+
+function readBlock(
+  lines: readonly string[],
+  index: number,
+  canFence: boolean,
+): { block: FormatBlock; nextIndex: number } {
+  const line = lines[index] ?? ''
+  const fence = canFence ? readFence(lines, index) : undefined
+  if (fence) return { block: { kind: 'pre', value: fence.value }, nextIndex: fence.nextIndex }
+  if (QUOTE_PREFIX.test(line)) return readQuote(lines, index)
+  if (BULLET_PREFIX.test(line) || ORDERED_PREFIX.test(line)) return readList(lines, index)
+  return readParagraph(lines, index)
+}
+
+export function parseParticipantMessage(text: string | null | undefined): readonly FormatBlock[] {
+  if (typeof text !== 'string' || text.trim() === '') return []
+  if (text.length > MAX_FORMATTED_LENGTH) return plainParagraph(text)
+  const lines = text.split(/\r\n?|\n/)
+  const blocks: FormatBlock[] = []
+  let canFence = true
+  let index = 0
+  while (index < lines.length) {
+    const { block, nextIndex } = readBlock(lines, index, canFence)
+    if (block.kind === 'paragraph' && startsFenceLine(lines[index])) canFence = false
+    blocks.push(block)
+    index = nextIndex
+  }
+  return blocks
+}
+
+function startsFenceLine(line: string | undefined): boolean {
+  return (line ?? '').trimStart().startsWith(FENCE)
+}

package/src/participant/participantMessageFormat.types.ts

@@ -0,0 +1,22 @@
+export type CopyableKind = 'phone' | 'email' | 'cpf' | 'cnpj' | 'accessKey'
+
+export type InlineNode =
+  | { readonly kind: 'text'; readonly value: string }
+  | { readonly kind: 'strong' | 'em' | 'del'; readonly children: readonly InlineNode[] }
+  | { readonly kind: 'code'; readonly value: string }
+  | { readonly kind: 'link'; readonly href: string; readonly label: string }
+  | { readonly kind: 'copyable'; readonly copyKind: CopyableKind; readonly value: string }
+
+export type FormatBlock =
+  | { readonly kind: 'paragraph'; readonly children: readonly InlineNode[] }
+  | { readonly kind: 'pre'; readonly value: string }
+  | { readonly kind: 'quote'; readonly children: readonly InlineNode[] }
+  | {
+      readonly kind: 'list'
+      readonly ordered: boolean
+      readonly start: number
+      readonly items: readonly (readonly InlineNode[])[]
+    }
+
+/** A span of the line that is atomic: nothing inside it is formatted. */
+export type InlineAtom = { readonly start: number; readonly end: number; readonly node: InlineNode }