@adatechnology/conversations-ui 0.6.1 → 0.7.0

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 }

package/src/participant/participantMessageInline.test.ts

@@ -0,0 +1,82 @@
+import { describe, expect, it } from 'bun:test'
+
+import { show } from './participantMessageFormat.test-helper'
+import { parseInline } from './participantMessageInline'
+
+function inline(line: string): string {
+  return show(parseInline(line))
+}
+
+describe('parseInline - basic marks', () => {
+  it('formats bold, italic, strike and inline code', () => {
+    expect(inline('*a b*')).toBe('⟦s:a b⟧')
+    expect(inline('x *a* y')).toBe('x ⟦s:a⟧ y')
+    expect(inline('_a b_')).toBe('⟦e:a b⟧')
+    expect(inline('~a b~')).toBe('⟦d:a b⟧')
+    expect(inline('`a b`')).toBe('⟦c:a b⟧')
+    expect(inline('oi *tudo* _bem_ ~mal~ `ok`')).toBe('oi ⟦s:tudo⟧ ⟦e:bem⟧ ⟦d:mal⟧ ⟦c:ok⟧')
+  })
+
+  it('formats marks that touch punctuation', () => {
+    expect(inline('(*a*)')).toBe('(⟦s:a⟧)')
+    expect(inline('*a*, _b_.')).toBe('⟦s:a⟧, ⟦e:b⟧.')
+  })
+
+  it('treats triple backticks in the middle of a line as inline code', () => {
+    expect(inline('veja ```x y``` aqui')).toBe('veja ⟦c:x y⟧ aqui')
+  })
+})
+
+describe('parseInline - nesting', () => {
+  it('nests valid combinations in both orders', () => {
+    expect(inline('*_negrito itálico_*')).toBe('⟦s:⟦e:negrito itálico⟧⟧')
+    expect(inline('_*assim*_')).toBe('⟦e:⟦s:assim⟧⟧')
+    expect(inline('~*_x_*~')).toBe('⟦d:⟦s:⟦e:x⟧⟧⟧')
+    expect(inline('*a _b_ c*')).toBe('⟦s:a ⟦e:b⟧ c⟧')
+  })
+
+  it('does not let crossing marks form invalid trees', () => {
+    expect(inline('*a _b* c_')).toBe('⟦s:a _b⟧ c_')
+    expect(inline('_a *b_ c*')).toBe('⟦e:a *b⟧ c*')
+  })
+
+  it('keeps code inside marks and never formats inside code', () => {
+    expect(inline('*a `b` c*')).toBe('⟦s:a ⟦c:b⟧ c⟧')
+    expect(inline('`*a*`')).toBe('⟦c:*a*⟧')
+    expect(inline('`_a_ ~b~`')).toBe('⟦c:_a_ ~b~⟧')
+  })
+})
+
+describe('parseInline - loose markers', () => {
+  it('does not format when the marker is glued to whitespace', () => {
+    expect(inline('* a *')).toBe('* a *')
+    expect(inline('2 * 3 * 4')).toBe('2 * 3 * 4')
+    expect(inline('_ a _')).toBe('_ a _')
+    expect(inline('~ a ~')).toBe('~ a ~')
+  })
+
+  it('does not format inside a word', () => {
+    expect(inline('snake_case_nome')).toBe('snake_case_nome')
+    expect(inline('a*b*c')).toBe('a*b*c')
+    expect(inline('2*3*4')).toBe('2*3*4')
+  })
+
+  it('leaves unmatched and empty markers alone', () => {
+    expect(inline('*a')).toBe('*a')
+    expect(inline('a*')).toBe('a*')
+    expect(inline('**')).toBe('**')
+    expect(inline('__')).toBe('__')
+    expect(inline('``')).toBe('``')
+    expect(inline('`aberto')).toBe('`aberto')
+  })
+})
+
+describe('parseInline - emoji', () => {
+  it('keeps ZWJ sequences, flags, skin tones and variation selectors intact', () => {
+    expect(inline('*👨‍👩‍👧*')).toBe('⟦s:👨‍👩‍👧⟧')
+    expect(inline('🇧🇷 _oi_')).toBe('🇧🇷 ⟦e:oi⟧')
+    expect(inline('👍🏽*x*')).toBe('👍🏽⟦s:x⟧')
+    expect(inline('‼️ ~não~')).toBe('‼️ ⟦d:não⟧')
+    expect(inline('👨‍👩‍👧 🇧🇷 👍🏽 ‼️')).toBe('👨‍👩‍👧 🇧🇷 👍🏽 ‼️')
+  })
+})

package/src/participant/participantMessageInline.ts

@@ -0,0 +1,99 @@
+import { findInlineAtoms } from './participantMessageAtoms'
+import type { InlineAtom, InlineNode } from './participantMessageFormat.types'
+
+type MarkKind = 'strong' | 'em' | 'del'
+
+const MARKS: Readonly<Record<string, MarkKind>> = { '*': 'strong', _: 'em', '~': 'del' }
+
+type LineContext = {
+  readonly text: string
+  readonly atomAt: ReadonlyMap<number, InlineAtom>
+  readonly isMasked: readonly boolean[]
+  readonly closers: Readonly<Record<string, readonly number[]>>
+}
+
+function isWord(character: string | undefined): boolean {
+  return character !== undefined && /[\p{L}\p{N}]/u.test(character)
+}
+
+function isSpace(character: string | undefined): boolean {
+  return character === undefined || /\s/u.test(character)
+}
+
+function characterBefore(text: string, index: number): string | undefined {
+  if (index <= 0) return undefined
+  const code = text.charCodeAt(index - 1)
+  const isLowSurrogate = code >= 0xdc00 && code <= 0xdfff
+  if (isLowSurrogate && index >= 2) return String.fromCodePoint(text.codePointAt(index - 2) ?? code)
+  return text.charAt(index - 1)
+}
+
+function buildContext(text: string): LineContext {
+  const atoms = findInlineAtoms(text)
+  const isMasked: boolean[] = new Array<boolean>(text.length).fill(false)
+  for (const atom of atoms) isMasked.fill(true, atom.start, atom.end)
+  const closers: Record<string, number[]> = { '*': [], _: [], '~': [] }
+  for (let index = 1; index < text.length; index += 1) {
+    const character = text.charAt(index)
+    const list = closers[character]
+    const isCloser = list !== undefined && !isMasked[index] && !isSpace(text[index - 1]) && !isWord(text[index + 1])
+    if (isCloser) list.push(index)
+  }
+  return { text, atomAt: new Map(atoms.map((atom) => [atom.start, atom])), isMasked, closers }
+}
+
+function isOpener(context: LineContext, index: number): boolean {
+  const { text } = context
+  const next = text[index + 1]
+  if (context.isMasked[index] || next === undefined || isSpace(next) || next === text[index]) return false
+  return !isWord(characterBefore(text, index))
+}
+
+function findCloser(context: LineContext, mark: string, from: number, limit: number): number | undefined {
+  const list = context.closers[mark] ?? []
+  let low = 0
+  let high = list.length
+  while (low < high) {
+    const middle = (low + high) >> 1
+    if ((list[middle] ?? 0) < from) low = middle + 1
+    else high = middle
+  }
+  const found = list[low]
+  return found !== undefined && found < limit ? found : undefined
+}
+
+function parseRange(context: LineContext, start: number, end: number): InlineNode[] {
+  const nodes: InlineNode[] = []
+  let textStart = start
+  let index = start
+  const flush = (until: number): void => {
+    if (until > textStart) nodes.push({ kind: 'text', value: context.text.slice(textStart, until) })
+  }
+  while (index < end) {
+    const atom = context.atomAt.get(index)
+    const mark = MARKS[context.text.charAt(index)]
+    const closer =
+      mark !== undefined && !atom && isOpener(context, index)
+        ? findCloser(context, context.text.charAt(index), index + 2, end)
+        : undefined
+    if (atom) {
+      flush(index)
+      nodes.push(atom.node)
+      index = atom.end
+    } else if (mark !== undefined && closer !== undefined) {
+      flush(index)
+      nodes.push({ kind: mark, children: parseRange(context, index + 1, closer) })
+      index = closer + 1
+    } else {
+      index += 1
+      continue
+    }
+    textStart = index
+  }
+  flush(end)
+  return nodes
+}
+
+export function parseInline(line: string): InlineNode[] {
+  return parseRange(buildContext(line), 0, line.length)
+}

package/src/participant/participantMessageLinks.test.ts

@@ -0,0 +1,100 @@
+import { describe, expect, it } from 'bun:test'
+
+import { show } from './participantMessageFormat.test-helper'
+import { isAllowedLinkHref } from './participantMessageLinks'
+import { parseInline } from './participantMessageInline'
+
+function inline(line: string): string {
+  return show(parseInline(line))
+}
+
+describe('isAllowedLinkHref', () => {
+  it('accepts only http, https, mailto and tel', () => {
+    expect(isAllowedLinkHref('http://a.com')).toBe(true)
+    expect(isAllowedLinkHref('https://a.com/x?y=1')).toBe(true)
+    expect(isAllowedLinkHref('HTTPS://A.COM')).toBe(true)
+    expect(isAllowedLinkHref('mailto:a@b.co')).toBe(true)
+    expect(isAllowedLinkHref('tel:+5511987654321')).toBe(true)
+  })
+
+  it('rejects every other protocol and non-URLs', () => {
+    expect(isAllowedLinkHref('javascript:alert(1)')).toBe(false)
+    expect(isAllowedLinkHref(' javascript:alert(1)')).toBe(false)
+    expect(isAllowedLinkHref('JaVaScRiPt:alert(1)')).toBe(false)
+    expect(isAllowedLinkHref('data:text/html,<b>x</b>')).toBe(false)
+    expect(isAllowedLinkHref('vbscript:x')).toBe(false)
+    expect(isAllowedLinkHref('file:///etc/passwd')).toBe(false)
+    expect(isAllowedLinkHref('ftp://a.com')).toBe(false)
+    expect(isAllowedLinkHref('//a.com')).toBe(false)
+    expect(isAllowedLinkHref('/relativo')).toBe(false)
+    expect(isAllowedLinkHref('')).toBe(false)
+  })
+})
+
+describe('autolink - http and https', () => {
+  it('links plain URLs and keeps the literal as the label', () => {
+    expect(inline('veja https://a.com/x agora')).toBe('veja ⟦l:https://a.com/x→https://a.com/x⟧ agora')
+    expect(inline('http://a.com')).toBe('⟦l:http://a.com→http://a.com⟧')
+  })
+
+  it('keeps trailing punctuation outside the link', () => {
+    expect(inline('https://a.com.')).toBe('⟦l:https://a.com→https://a.com⟧.')
+    expect(inline('https://a.com,')).toBe('⟦l:https://a.com→https://a.com⟧,')
+    expect(inline('https://a.com;')).toBe('⟦l:https://a.com→https://a.com⟧;')
+    expect(inline('https://a.com:')).toBe('⟦l:https://a.com→https://a.com⟧:')
+    expect(inline('https://a.com!')).toBe('⟦l:https://a.com→https://a.com⟧!')
+    expect(inline('https://a.com?')).toBe('⟦l:https://a.com→https://a.com⟧?')
+    expect(inline('https://a.com/x...')).toBe('⟦l:https://a.com/x→https://a.com/x⟧...')
+  })
+
+  it('keeps balanced parentheses inside and drops the unbalanced one', () => {
+    expect(inline('(veja https://a.com/p)')).toBe('(veja ⟦l:https://a.com/p→https://a.com/p⟧)')
+    expect(inline('https://a.com/p_(x)')).toBe('⟦l:https://a.com/p_(x)→https://a.com/p_(x)⟧')
+    expect(inline('(https://a.com/p_(x))')).toBe('(⟦l:https://a.com/p_(x)→https://a.com/p_(x)⟧)')
+  })
+
+  it('keeps query strings and ampersands', () => {
+    expect(inline('https://a.com/?a=1&b=2')).toBe('⟦l:https://a.com/?a=1&b=2→https://a.com/?a=1&b=2⟧')
+  })
+
+  it('accepts an uppercase scheme, normalising only the scheme of the href', () => {
+    expect(inline('HTTP://MAIUSCULO')).toBe('⟦l:HTTP://MAIUSCULO→http://MAIUSCULO⟧')
+  })
+
+  it('does not format marks inside a URL, but a mark may wrap it', () => {
+    expect(inline('https://a.com/_x_/~y~/*z*')).toBe('⟦l:https://a.com/_x_/~y~/*z→https://a.com/_x_/~y~/*z⟧*')
+    expect(inline('*https://a.com*')).toBe('⟦s:⟦l:https://a.com→https://a.com⟧⟧')
+  })
+
+  it('does not link a scheme with nothing after it, nor inside code', () => {
+    expect(inline('https://')).toBe('https://')
+    expect(inline('`https://a.com`')).toBe('⟦c:https://a.com⟧')
+  })
+})
+
+describe('autolink - unsafe protocols stay text', () => {
+  it('never links javascript, data or vbscript', () => {
+    expect(inline('javascript:alert(1)')).toBe('javascript:alert(1)')
+    expect(inline('data:text/html,<script>alert(1)</script>')).toBe('data:text/html,<script>alert(1)</script>')
+    expect(inline('vbscript:msgbox(1)')).toBe('vbscript:msgbox(1)')
+    expect(inline('clique: javascript://%0aalert(1)')).toBe('clique: javascript://%0aalert(1)')
+  })
+})
+
+describe('autolink - cost and userinfo', () => {
+  it('trims a long run of closing parentheses in linear time', () => {
+    const started = performance.now()
+    inline(`https://a${')'.repeat(7990)}`)
+    expect(performance.now() - started).toBeLessThan(20)
+  })
+
+  it('still balances parentheses', () => {
+    expect(inline('https://a.com/x_(y))')).toBe('⟦l:https://a.com/x_(y)→https://a.com/x_(y)⟧)')
+  })
+
+  it('leaves a link with credentials as text', () => {
+    expect(isAllowedLinkHref('https://user:pass@a.com')).toBe(false)
+    expect(isAllowedLinkHref('https://user@a.com')).toBe(false)
+    expect(inline('https://user:pass@a.com/x')).not.toContain('⟦l:')
+  })
+})