@adatechnology/conversations-ui 0.8.0 → 0.10.0

package/src/participant/participantAudioRecorderInterruptionDom.test.tsx

@@ -0,0 +1,135 @@
+import { act } from 'react'
+
+import { describe, expect, it } from 'bun:test'
+
+import { setupRecorderDom } from './participantRecorderDomKit.test-helper'
+
+const kit = setupRecorderDom()
+const { mountProbe, start, advance, recordFor, deferStream, hidePage } = kit
+
+describe('the duration ceiling', () => {
+  it('stops by itself at the ceiling and lands in review', async () => {
+    mountProbe({ maxDurationMs: 2000 })
+    await recordFor(1000)
+    expect(kit.api.status).toBe('recording')
+    await advance(1100)
+    expect(kit.api.status).toBe('review')
+  })
+
+  it('shows the elapsed time while recording', async () => {
+    mountProbe()
+    await recordFor(3000)
+    expect(kit.api.elapsedMs).toBeGreaterThanOrEqual(2750)
+  })
+})
+
+describe('cancellation token of getUserMedia (contract 2.1)', () => {
+  it('unmount while requesting: a late stream gets every track stopped at once', async () => {
+    deferStream()
+    const tree = mountProbe()
+    await start()
+    tree.unmount()
+    await act(async () => kit.resolveStream?.(kit.stream))
+    expect(kit.stream.track.stopCount).toBe(1)
+  })
+
+  it('page hidden while requesting: back to idle and the late kit.stream is stopped', async () => {
+    deferStream()
+    mountProbe()
+    await start()
+    hidePage()
+    expect(kit.api.status).toBe('idle')
+    await act(async () => kit.resolveStream?.(kit.stream))
+    expect(kit.stream.track.stopCount).toBe(1)
+    expect(kit.api.status).toBe('idle')
+  })
+
+  it('pagehide while requesting also cancels', async () => {
+    deferStream()
+    mountProbe()
+    await start()
+    act(() => {
+      window.dispatchEvent(new Event('pagehide'))
+    })
+    await act(async () => kit.resolveStream?.(kit.stream))
+    expect(kit.stream.track.stopCount).toBe(1)
+    expect(kit.api.status).toBe('idle')
+  })
+})
+
+describe('interruptions (contract 2.1)', () => {
+  it('track.onended while recording stops and goes to review', async () => {
+    mountProbe()
+    await recordFor(1000)
+    act(() => kit.stream.track.onended?.())
+    expect(kit.api.status).toBe('review')
+  })
+
+  it('a mute shorter than 3 s does not interrupt', async () => {
+    mountProbe()
+    await recordFor(1000)
+    act(() => kit.stream.track.onmute?.())
+    await advance(2900)
+    act(() => kit.stream.track.onunmute?.())
+    await advance(5000)
+    expect(kit.api.status).toBe('recording')
+  })
+
+  it('a mute that persists past 3 s interrupts', async () => {
+    mountProbe()
+    await recordFor(1000)
+    act(() => kit.stream.track.onmute?.())
+    await advance(2900)
+    expect(kit.api.status).toBe('recording')
+    await advance(200)
+    expect(kit.api.status).toBe('review')
+  })
+
+  it('page hidden while recording stops and goes to review', async () => {
+    mountProbe()
+    await recordFor(1000)
+    hidePage()
+    expect(kit.api.status).toBe('review')
+  })
+
+  it('pagehide while recording stops and goes to review', async () => {
+    mountProbe()
+    await recordFor(1000)
+    act(() => {
+      window.dispatchEvent(new Event('pagehide'))
+    })
+    expect(kit.api.status).toBe('review')
+  })
+
+  it('page hidden in review pauses the player and KEEPS the recording', async () => {
+    mountProbe()
+    await recordFor(1000)
+    act(() => kit.api.stop())
+    let paused = 0
+    ;(kit.api.audioRef as { current: unknown }).current = { pause: () => (paused += 1) }
+    hidePage()
+    expect(paused).toBe(1)
+    expect(kit.api.status).toBe('review')
+    expect(kit.api.recorded?.file.size).toBe(4096)
+    expect(kit.revoked).toEqual([])
+  })
+})
+
+describe('unmount discards everything', () => {
+  it('while recording: tracks stopped, capture reported off', async () => {
+    const tree = mountProbe()
+    await recordFor(1000)
+    tree.unmount()
+    expect(kit.stream.track.stopCount).toBeGreaterThan(0)
+    expect(kit.captureEvents.at(-1)).toBe(false)
+  })
+
+  it('in review: the object URL is revoked', async () => {
+    const tree = mountProbe()
+    await recordFor(1000)
+    act(() => kit.api.stop())
+    tree.unmount()
+    expect(kit.revoked).toEqual(['blob:fake-recording'])
+    expect(kit.captureEvents.at(-1)).toBe(false)
+  })
+})

package/src/participant/participantAudioRecorderSpecDom.test.tsx

@@ -0,0 +1,110 @@
+import { act } from 'react'
+
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, jest } from 'bun:test'
+
+import { setupDom, type DomHarness } from '../domHarness.test-helper'
+import { SpecMediaRecorder, SpecStream } from './participantSpecRecorderFake.test-helper'
+import { useParticipantAudioRecorder } from './useParticipantAudioRecorder'
+
+let harness: DomHarness
+let api: ReturnType<typeof useParticipantAudioRecorder>
+let stream: SpecStream
+
+let probeMaxDurationMs: number | undefined
+
+function Probe() {
+  api = useParticipantAudioRecorder(
+    probeMaxDurationMs === undefined ? {} : { options: { maxDurationMs: probeMaxDurationMs } },
+  )
+  return null
+}
+
+async function flush(): Promise<void> {
+  await act(async () => {
+    await Promise.resolve()
+    await Promise.resolve()
+  })
+}
+
+async function startAndRecord(): Promise<void> {
+  harness.mount(<Probe />)
+  await act(async () => {
+    void api.start()
+  })
+  await act(async () => {
+    jest.advanceTimersByTime(1000)
+  })
+}
+
+function hidePage(): void {
+  Object.defineProperty(document, 'visibilityState', { configurable: true, get: () => 'hidden' })
+  act(() => {
+    document.dispatchEvent(new Event('visibilitychange'))
+  })
+  Object.defineProperty(document, 'visibilityState', { configurable: true, get: () => 'visible' })
+}
+
+beforeAll(async () => {
+  harness = await setupDom()
+})
+
+afterAll(() => harness.teardown())
+
+beforeEach(() => {
+  probeMaxDurationMs = undefined
+  jest.useFakeTimers()
+  SpecMediaRecorder.instances = []
+  stream = new SpecStream()
+  ;(globalThis as Record<string, unknown>).MediaRecorder = SpecMediaRecorder
+  ;(navigator as unknown as Record<string, unknown>).mediaDevices = { getUserMedia: async () => stream }
+  URL.createObjectURL = () => 'blob:fake-recording'
+  URL.revokeObjectURL = () => {}
+})
+
+afterEach(() => {
+  jest.useRealTimers()
+  delete (globalThis as Record<string, unknown>).MediaRecorder
+})
+
+describe('a recorder that follows the MediaRecorder specification (stop is asynchronous)', () => {
+  it('stopping twice still ends in review with the audio', async () => {
+    await startAndRecord()
+    act(() => {
+      api.stop()
+      api.stop()
+    })
+    await flush()
+    expect(api.status).toBe('review')
+    expect(api.recorded?.file.size).toBe(4096)
+    expect(SpecMediaRecorder.instances[0]?.stopCalls).toBe(1)
+  })
+
+  it('track.onended after the recorder stopped by itself still ends in review', async () => {
+    await startAndRecord()
+    SpecMediaRecorder.instances[0]?.autoStop()
+    act(() => stream.track.onended?.())
+    await flush()
+    expect(api.status).toBe('review')
+    expect(api.recorded?.file.size).toBe(4096)
+  })
+
+  it('the page becoming hidden right after Stop still ends in review', async () => {
+    await startAndRecord()
+    act(() => api.stop())
+    hidePage()
+    await flush()
+    expect(api.status).toBe('review')
+    expect(api.recorded?.file.size).toBe(4096)
+  })
+
+  it('the duration ceiling coinciding with Stop still ends in review', async () => {
+    probeMaxDurationMs = 3000
+    await startAndRecord()
+    act(() => api.stop())
+    await act(async () => {
+      jest.advanceTimersByTime(4000)
+    })
+    await flush()
+    expect(api.status).toBe('review')
+  })
+})

package/src/participant/participantAudioRecorderState.test.ts

@@ -0,0 +1,144 @@
+import { describe, expect, it } from 'bun:test'
+
+import { DEFAULT_MAX_RECORDING_MILLISECONDS } from '../audioRecorderFormat'
+import {
+  canStartRecording,
+  classifyCapture,
+  classifyMicrophoneError,
+  formatRecordingClock,
+  MINIMUM_RECORDING_MILLISECONDS,
+  reduceRecorderStatus,
+  resolveInterruptionAction,
+  resolveRecordingLimits,
+  type RecorderEvent,
+  type RecorderStatus,
+} from './participantAudioRecorderState'
+import { DEFAULT_MAX_RECORDING_BYTES } from './participantAudio.types'
+
+const SIXTEEN_MIB = 16 * 1024 * 1024
+
+describe('resolveRecordingLimits only lowers the defaults (contract 2)', () => {
+  it('uses the defaults when nothing is passed', () => {
+    expect(resolveRecordingLimits({})).toEqual({ maxDurationMs: DEFAULT_MAX_RECORDING_MILLISECONDS, maxSizeBytes: SIXTEEN_MIB })
+    expect(DEFAULT_MAX_RECORDING_BYTES).toBe(SIXTEEN_MIB)
+  })
+
+  it('lowers the duration and the size', () => {
+    expect(resolveRecordingLimits({ options: { maxDurationMs: 60_000, maxSizeBytes: 1_000_000 } })).toEqual({
+      maxDurationMs: 60_000,
+      maxSizeBytes: 1_000_000,
+    })
+  })
+
+  it('cuts a larger duration or size back to the default', () => {
+    const limits = resolveRecordingLimits({ options: { maxDurationMs: 3_600_000, maxSizeBytes: 100 * 1024 * 1024 } })
+    expect(limits.maxDurationMs).toBe(DEFAULT_MAX_RECORDING_MILLISECONDS)
+    expect(limits.maxSizeBytes).toBe(SIXTEEN_MIB)
+  })
+
+  it('takes the smallest of the policy, the channel and the passed value', () => {
+    expect(resolveRecordingLimits({ channelMaxBytes: 10 * 1024 * 1024 }).maxSizeBytes).toBe(10 * 1024 * 1024)
+    expect(resolveRecordingLimits({ channelMaxBytes: 25 * 1024 * 1024 }).maxSizeBytes).toBe(SIXTEEN_MIB)
+    expect(resolveRecordingLimits({ options: { maxSizeBytes: 5_000_000 }, channelMaxBytes: 10_000_000 }).maxSizeBytes).toBe(5_000_000)
+  })
+
+  it('ignores values that are not a positive number', () => {
+    for (const bad of [0, -5, Number.NaN]) {
+      expect(resolveRecordingLimits({ options: { maxDurationMs: bad, maxSizeBytes: bad } })).toEqual({
+        maxDurationMs: DEFAULT_MAX_RECORDING_MILLISECONDS,
+        maxSizeBytes: SIXTEEN_MIB,
+      })
+    }
+  })
+})
+
+describe('reduceRecorderStatus', () => {
+  const table: ReadonlyArray<readonly [RecorderStatus, RecorderEvent, RecorderStatus]> = [
+    ['idle', 'request', 'requesting'],
+    ['denied', 'request', 'requesting'],
+    ['unsupported', 'request', 'requesting'],
+    ['empty', 'request', 'requesting'],
+    ['tooLarge', 'request', 'requesting'],
+    ['requesting', 'granted', 'recording'],
+    ['requesting', 'microphoneDenied', 'denied'],
+    ['requesting', 'microphoneUnavailable', 'unsupported'],
+    ['requesting', 'cancel', 'idle'],
+    ['recording', 'capturedReview', 'review'],
+    ['recording', 'capturedEmpty', 'empty'],
+    ['recording', 'capturedTooLarge', 'tooLarge'],
+    ['recording', 'cancel', 'idle'],
+    ['review', 'cancel', 'idle'],
+  ]
+
+  for (const [from, event, to] of table) {
+    it(`${from} + ${event} -> ${to}`, () => {
+      expect(reduceRecorderStatus(from, event)).toBe(to)
+    })
+  }
+
+  it('ignores events that do not apply to the current state', () => {
+    expect(reduceRecorderStatus('recording', 'request')).toBe('recording')
+    expect(reduceRecorderStatus('review', 'request')).toBe('review')
+    expect(reduceRecorderStatus('requesting', 'request')).toBe('requesting')
+    expect(reduceRecorderStatus('idle', 'granted')).toBe('idle')
+    expect(reduceRecorderStatus('review', 'capturedEmpty')).toBe('review')
+  })
+})
+
+describe('resolveInterruptionAction (contract 2.1)', () => {
+  it('stops a recording, pauses a review, cancels a pending request', () => {
+    expect(resolveInterruptionAction('recording')).toBe('stop')
+    expect(resolveInterruptionAction('review')).toBe('pause')
+    expect(resolveInterruptionAction('requesting')).toBe('cancel')
+  })
+
+  it('ignores the idle and error states', () => {
+    for (const status of ['idle', 'denied', 'unsupported', 'empty', 'tooLarge'] as const) {
+      expect(resolveInterruptionAction(status)).toBe('ignore')
+    }
+  })
+})
+
+describe('classifyCapture', () => {
+  const limits = { maxDurationMs: 300_000, maxSizeBytes: 1000 }
+
+  it('is empty without bytes or below the minimum duration', () => {
+    expect(classifyCapture({ sizeBytes: 0, durationMs: 5000 }, limits)).toBe('capturedEmpty')
+    expect(classifyCapture({ sizeBytes: 500, durationMs: 0 }, limits)).toBe('capturedEmpty')
+    expect(classifyCapture({ sizeBytes: 500, durationMs: MINIMUM_RECORDING_MILLISECONDS - 1 }, limits)).toBe('capturedEmpty')
+  })
+
+  it('is too large above the byte ceiling and fine at it', () => {
+    expect(classifyCapture({ sizeBytes: 1001, durationMs: 5000 }, limits)).toBe('capturedTooLarge')
+    expect(classifyCapture({ sizeBytes: 1000, durationMs: MINIMUM_RECORDING_MILLISECONDS }, limits)).toBe('capturedReview')
+  })
+})
+
+describe('classifyMicrophoneError', () => {
+  it('maps the permission errors to denied and the rest to unavailable', () => {
+    expect(classifyMicrophoneError({ name: 'NotAllowedError' })).toBe('microphoneDenied')
+    expect(classifyMicrophoneError({ name: 'SecurityError' })).toBe('microphoneDenied')
+    for (const name of ['NotFoundError', 'NotReadableError', 'OverconstrainedError', 'AbortError']) {
+      expect(classifyMicrophoneError({ name })).toBe('microphoneUnavailable')
+    }
+    expect(classifyMicrophoneError('boom')).toBe('microphoneUnavailable')
+    expect(classifyMicrophoneError(undefined)).toBe('microphoneUnavailable')
+  })
+})
+
+describe('formatRecordingClock', () => {
+  it('formats m:ss, flooring the seconds', () => {
+    expect(formatRecordingClock(0)).toBe('0:00')
+    expect(formatRecordingClock(12_999)).toBe('0:12')
+    expect(formatRecordingClock(65_000)).toBe('1:05')
+    expect(formatRecordingClock(300_000)).toBe('5:00')
+    expect(formatRecordingClock(-10)).toBe('0:00')
+  })
+})
+
+describe('canStartRecording', () => {
+  it('lets a tap start only from idle and the failure states', () => {
+    for (const status of ['idle', 'denied', 'unsupported', 'empty', 'tooLarge'] as const) expect(canStartRecording(status)).toBe(true)
+    for (const status of ['requesting', 'recording', 'review'] as const) expect(canStartRecording(status)).toBe(false)
+  })
+})

package/src/participant/participantAudioRecorderState.ts

@@ -0,0 +1,93 @@
+import { DEFAULT_MAX_RECORDING_MILLISECONDS } from '../audioRecorderFormat'
+import { DEFAULT_MAX_RECORDING_BYTES, type ParticipantAudioRecordingOptions } from './participantAudio.types'
+
+export type RecorderStatus =
+  | 'idle'
+  | 'requesting'
+  | 'recording'
+  | 'review'
+  | 'denied'
+  | 'unsupported'
+  | 'empty'
+  | 'tooLarge'
+
+export type RecorderEvent =
+  | 'request'
+  | 'granted'
+  | 'microphoneDenied'
+  | 'microphoneUnavailable'
+  | 'capturedReview'
+  | 'capturedEmpty'
+  | 'capturedTooLarge'
+  | 'cancel'
+
+export type InterruptionAction = 'stop' | 'pause' | 'cancel' | 'ignore'
+export type RecordingLimits = { readonly maxDurationMs: number; readonly maxSizeBytes: number }
+export type CaptureMeasure = { readonly sizeBytes: number; readonly durationMs: number }
+
+export const MINIMUM_RECORDING_MILLISECONDS = 500
+export const MUTE_INTERRUPTION_DELAY_MS = 3000
+
+const RETRYABLE: readonly RecorderStatus[] = ['idle', 'denied', 'unsupported', 'empty', 'tooLarge']
+
+const TRANSITIONS: Readonly<Record<RecorderEvent, ReadonlyArray<readonly [readonly RecorderStatus[], RecorderStatus]>>> = {
+  request: [[RETRYABLE, 'requesting']],
+  granted: [[['requesting'], 'recording']],
+  microphoneDenied: [[['requesting'], 'denied']],
+  microphoneUnavailable: [[['requesting'], 'unsupported']],
+  capturedReview: [[['recording'], 'review']],
+  capturedEmpty: [[['recording'], 'empty']],
+  capturedTooLarge: [[['recording'], 'tooLarge']],
+  cancel: [[['requesting', 'recording', 'review'], 'idle']],
+}
+
+export function canStartRecording(status: RecorderStatus): boolean {
+  return RETRYABLE.includes(status)
+}
+
+export function reduceRecorderStatus(status: RecorderStatus, event: RecorderEvent): RecorderStatus {
+  const match = TRANSITIONS[event].find(([from]) => from.includes(status))
+  return match ? match[1] : status
+}
+
+export function resolveInterruptionAction(status: RecorderStatus): InterruptionAction {
+  if (status === 'recording') return 'stop'
+  if (status === 'review') return 'pause'
+  if (status === 'requesting') return 'cancel'
+  return 'ignore'
+}
+
+function lowerOnly(requested: number | undefined, ceiling: number): number {
+  if (requested === undefined || !Number.isFinite(requested) || requested <= 0) return ceiling
+  return Math.min(requested, ceiling)
+}
+
+export type ResolveRecordingLimitsParams = {
+  readonly options?: ParticipantAudioRecordingOptions
+  readonly channelMaxBytes?: number
+}
+
+export function resolveRecordingLimits({ options, channelMaxBytes }: ResolveRecordingLimitsParams): RecordingLimits {
+  const sizeCeiling = lowerOnly(channelMaxBytes, DEFAULT_MAX_RECORDING_BYTES)
+  return {
+    maxDurationMs: lowerOnly(options?.maxDurationMs, DEFAULT_MAX_RECORDING_MILLISECONDS),
+    maxSizeBytes: lowerOnly(options?.maxSizeBytes, sizeCeiling),
+  }
+}
+
+export function classifyCapture({ sizeBytes, durationMs }: CaptureMeasure, limits: RecordingLimits): RecorderEvent {
+  if (sizeBytes === 0 || durationMs < MINIMUM_RECORDING_MILLISECONDS) return 'capturedEmpty'
+  if (sizeBytes > limits.maxSizeBytes) return 'capturedTooLarge'
+  return 'capturedReview'
+}
+
+export function classifyMicrophoneError(error: unknown): 'microphoneDenied' | 'microphoneUnavailable' {
+  const name = typeof error === 'object' && error !== null && 'name' in error ? (error as { name: unknown }).name : undefined
+  return name === 'NotAllowedError' || name === 'SecurityError' ? 'microphoneDenied' : 'microphoneUnavailable'
+}
+
+export function formatRecordingClock(milliseconds: number): string {
+  const totalSeconds = Math.floor(Math.max(0, milliseconds) / 1000)
+  const seconds = String(totalSeconds % 60).padStart(2, '0')
+  return `${Math.floor(totalSeconds / 60)}:${seconds}`
+}

package/src/participant/participantAudioRecorderView.test.tsx

@@ -0,0 +1,98 @@
+import { renderToStaticMarkup } from 'react-dom/server'
+
+import { describe, expect, it } from 'bun:test'
+
+import { ParticipantAudioRecorderView, type ParticipantAudioRecorderViewProps } from './ParticipantAudioRecorderView'
+import type { RecorderStatus } from './participantAudioRecorderState'
+import { DEFAULT_PARTICIPANT_CONVERSATIONS_LABELS } from './participantLabels'
+
+function render(overrides: Partial<ParticipantAudioRecorderViewProps> & { state: RecorderStatus }): string {
+  return renderToStaticMarkup(<ParticipantAudioRecorderView elapsedMs={12_000} {...overrides} />)
+}
+
+describe('idle and requesting', () => {
+  it('renders the microphone as a non-submitting primary button named by recordAudio', () => {
+    const markup = render({ state: 'idle' })
+    expect(markup).toContain('type="button"')
+    expect(markup).toContain('class="cv-p-button cv-p-button--primary cv-p-composer__record"')
+    expect(markup).toContain('aria-label="Record audio"')
+    expect(markup).not.toContain('type="submit"')
+    expect(markup).not.toContain('aria-busy')
+  })
+
+  it('is busy and disabled while the permission is pending', () => {
+    const markup = render({ state: 'requesting' })
+    expect(markup).toContain('aria-busy="true"')
+    expect(markup).toContain('disabled=""')
+  })
+
+  it('is disabled when the composer is', () => {
+    expect(render({ state: 'idle', disabled: true })).toContain('disabled=""')
+  })
+})
+
+describe('recording', () => {
+  it('shows the clock "m:ss of m:ss", discard and stop, and no aria-live', () => {
+    const markup = render({ state: 'recording' })
+    expect(markup).toContain('role="group"')
+    expect(markup).toContain('aria-label="Recording"')
+    expect(markup).toContain('role="timer"')
+    expect(markup).toContain('0:12 of 5:00')
+    expect(markup).toContain('cv-p-recorder__discard')
+    expect(markup).toContain('cv-p-recorder__stop')
+    expect(markup).not.toContain('aria-live')
+    expect(markup).not.toContain('cv-p-composer__record')
+  })
+
+  it('uses the lowered ceiling in the clock', () => {
+    expect(render({ state: 'recording', maxDurationMs: 90_000 })).toContain('0:12 of 1:30')
+  })
+
+  it('every button is type="button"', () => {
+    const buttons = render({ state: 'recording' }).match(/<button[^>]*>/g) ?? []
+    expect(buttons).toHaveLength(2)
+    for (const button of buttons) expect(button).toContain('type="button"')
+  })
+})
+
+describe('review', () => {
+  it('has the hint, the player over the object URL, discard and send', () => {
+    const markup = render({ state: 'review', review: { url: 'blob:abc' } })
+    expect(markup).toContain('cv-p-recorder--review')
+    expect(markup).toContain('<p class="cv-p-recorder__hint" aria-hidden="true">Listen before sending</p>')
+    expect(markup).toContain('<audio')
+    expect(markup).toContain('src="blob:abc"')
+    expect(markup).toContain('cv-p-recorder__discard')
+    expect(markup).toContain('cv-p-recorder__send')
+    expect(markup).toContain('aria-label="Send audio"')
+  })
+})
+
+describe('failure states', () => {
+  const cases: ReadonlyArray<readonly [RecorderStatus, string]> = [
+    ['denied', 'No permission to use the microphone.'],
+    ['unsupported', 'This device cannot record audio.'],
+    ['empty', 'Nothing was captured by the microphone.'],
+    ['tooLarge', 'Audio too large to send.'],
+  ]
+  for (const [state, text] of cases) {
+    it(`${state} keeps the microphone and announces the phrase as an alert`, () => {
+      const markup = render({ state })
+      expect(markup).toContain(`<p class="cv-p-composer__error" role="alert">${text}</p>`)
+      expect(markup).toContain('cv-p-composer__record')
+    })
+  }
+})
+
+describe('labels', () => {
+  it('uses the English defaults when the host map does not carry the new keys', () => {
+    const { recordAudio: _omitted, ...withoutAudio } = DEFAULT_PARTICIPANT_CONVERSATIONS_LABELS
+    expect(render({ state: 'idle', labels: withoutAudio })).toContain('aria-label="Record audio"')
+  })
+
+  it('takes the host translation when present', () => {
+    const labels = { ...DEFAULT_PARTICIPANT_CONVERSATIONS_LABELS, recordAudio: 'Gravar áudio', recordingElapsed: '{elapsed} de {limit}' }
+    expect(render({ state: 'idle', labels })).toContain('aria-label="Gravar áudio"')
+    expect(render({ state: 'recording', labels })).toContain('0:12 de 5:00')
+  })
+})

package/src/participant/participantAudioSupport.ts

@@ -0,0 +1,36 @@
+import { channelCapabilityFor } from '../channelCapability'
+import { resolveRecordingFormat, type RecordingFormat } from '../audioRecorderFormat'
+import type { ConversationChannel } from '../conversationChannel'
+import type { ParticipantAudioRecordingOptions } from './participantAudio.types'
+import { matchesAcceptedType } from './participantFileValidation'
+
+export type ComposerAudioSettings = {
+  readonly audioRecording: ParticipantAudioRecordingOptions
+  readonly channel: ConversationChannel
+  readonly onSendAudio: (file: File) => void
+}
+
+export type ResolveComposerAudioParams = {
+  readonly audioRecording?: ParticipantAudioRecordingOptions
+  readonly onSendAudio?: (file: File) => void
+  readonly channel?: ConversationChannel
+  readonly acceptedTypes?: readonly string[]
+}
+
+/** Feature detection only: on a server there is no MediaRecorder, so it answers false. */
+function resolveBrowserRecordingFormat(): RecordingFormat | undefined {
+  if (typeof navigator === 'undefined' || !navigator.mediaDevices?.getUserMedia) return undefined
+  return resolveRecordingFormat()
+}
+
+/** The host opts in through the prop; the channel and the browser can only switch the microphone off. */
+export function resolveComposerAudio(params: ResolveComposerAudioParams): ComposerAudioSettings | undefined {
+  const { audioRecording, onSendAudio, channel = 'app', acceptedTypes } = params
+  if (!audioRecording || !onSendAudio) return undefined
+  const capability = channelCapabilityFor(channel)
+  if (!capability.audio.records || !capability.attachments.accepted) return undefined
+  const format = resolveBrowserRecordingFormat()
+  if (!format) return undefined
+  if (acceptedTypes && !matchesAcceptedType(format.uploadMimeType, acceptedTypes)) return undefined
+  return { audioRecording, channel, onSendAudio }
+}