@adatechnology/conversations-ui 0.8.0 → 0.10.0

package/src/participant/participantAudioPlayerControlsDom.test.tsx

@@ -0,0 +1,123 @@
+import { act } from 'react'
+
+import { describe, expect, it } from 'bun:test'
+
+import { pressKey, wait } from '../domHarness.test-helper'
+import { ParticipantAudioRecorderView } from './ParticipantAudioRecorderView'
+import { DEFAULT_PARTICIPANT_AUDIO_LABELS } from './participantAudioLabels'
+import { buildAttachment, setupPlayerDom } from './participantAudioPlayerDomKit.test-helper'
+
+const kit = setupPlayerDom()
+const { mountAttachments, audioOf, toggleOf, find, tap } = kit
+
+describe('time and range', () => {
+  it('shows the server duration before the first tap', async () => {
+    await mountAttachments([buildAttachment('a', 65_000)])
+    expect(find('.cv-p-audio__time').textContent).toBe('0:00 / 1:05')
+    expect(find<HTMLInputElement>('.cv-p-audio__seek').getAttribute('max')).toBe('65')
+  })
+
+  it('uses loadedmetadata when the server sent no duration', async () => {
+    await mountAttachments([buildAttachment('a')])
+    expect(find('.cv-p-audio__time').textContent).toBe('0:00 / --:--')
+    kit.media.stateOf(audioOf()).duration = 42
+    act(() => kit.media.emit(audioOf(), 'loadedmetadata'))
+    expect(find('.cv-p-audio__time').textContent).toBe('0:00 / 0:42')
+  })
+
+  it('follows timeupdate and seeks by dragging the range', async () => {
+    await mountAttachments([buildAttachment('a', 65_000)])
+    kit.media.stateOf(audioOf()).currentTime = 12
+    act(() => kit.media.emit(audioOf(), 'timeupdate'))
+    expect(find('.cv-p-audio__time').textContent).toBe('0:12 / 1:05')
+    expect(find('.cv-p-audio__seek').getAttribute('aria-valuetext')).toBe('0:12 of 1:05')
+    const range = find<HTMLInputElement>('.cv-p-audio__seek')
+    act(() => {
+      Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, 'value')?.set?.call(range, '30')
+      range.dispatchEvent(new Event('input', { bubbles: true }))
+    })
+    expect(kit.media.stateOf(audioOf()).currentTime).toBe(30)
+  })
+
+  it('steps 5 seconds with the arrows and jumps with Home and End', async () => {
+    await mountAttachments([buildAttachment('a', 65_000)])
+    const range = find('.cv-p-audio__seek')
+    pressKey(range, 'ArrowRight')
+    expect(kit.media.stateOf(audioOf()).currentTime).toBe(5)
+    pressKey(range, 'ArrowRight')
+    pressKey(range, 'ArrowLeft')
+    expect(kit.media.stateOf(audioOf()).currentTime).toBe(5)
+    pressKey(range, 'End')
+    expect(kit.media.stateOf(audioOf()).currentTime).toBe(65)
+    pressKey(range, 'Home')
+    expect(kit.media.stateOf(audioOf()).currentTime).toBe(0)
+  })
+
+  it('tolerates an infinite duration: no broken max, value text with the position only', async () => {
+    await mountAttachments([buildAttachment('a')])
+    kit.media.stateOf(audioOf()).duration = Number.POSITIVE_INFINITY
+    act(() => kit.media.emit(audioOf(), 'durationchange'))
+    kit.media.stateOf(audioOf()).currentTime = 12
+    act(() => kit.media.emit(audioOf(), 'timeupdate'))
+    const range = find('.cv-p-audio__seek')
+    expect(range.getAttribute('max')).toBe('12')
+    expect(range.getAttribute('aria-valuetext')).toBe('0:12')
+    expect(find('.cv-p-audio__time').textContent).toBe('0:12 / --:--')
+  })
+})
+
+describe('speed', () => {
+  it('cycles 1x, 1.5x, 2x applying defaultPlaybackRate and playbackRate', async () => {
+    await mountAttachments([buildAttachment('a')])
+    const rate = find('.cv-p-audio__rate')
+    expect(rate.textContent).toBe('1×')
+    tap(rate)
+    expect(rate.textContent).toBe('1.5×')
+    expect(rate.getAttribute('aria-label')).toBe('Playback speed 1.5×')
+    expect(kit.media.stateOf(audioOf()).defaultPlaybackRate).toBe(1.5)
+    expect(kit.media.stateOf(audioOf()).playbackRate).toBe(1.5)
+    tap(rate)
+    expect(kit.media.stateOf(audioOf()).playbackRate).toBe(2)
+    tap(rate)
+    expect(kit.media.stateOf(audioOf()).playbackRate).toBe(1)
+  })
+})
+
+describe('expired signed URL', () => {
+  it('re-resolves once on a media error, swaps the src and resumes from the same position', async () => {
+    await mountAttachments([buildAttachment('a', 65_000)])
+    tap(toggleOf())
+    kit.media.stateOf(audioOf()).currentTime = 12
+    act(() => kit.media.emit(audioOf(), 'error'))
+    await wait(0)
+    expect(kit.resolverCalls).toEqual(['a', 'a'])
+    expect(audioOf().getAttribute('src')).toBe('https://files.test/a-2.webm')
+    expect(kit.media.stateOf(audioOf()).currentTime).toBe(12)
+    expect(kit.media.playCalls.length).toBe(2)
+  })
+
+  it('gives up after the single retry and says the audio is unavailable', async () => {
+    await mountAttachments([buildAttachment('a', 65_000)])
+    tap(toggleOf())
+    act(() => kit.media.emit(audioOf(), 'error'))
+    await wait(0)
+    act(() => kit.media.emit(audioOf(), 'error'))
+    await wait(0)
+    expect(kit.resolverCalls).toEqual(['a', 'a'])
+    expect(kit.container.textContent).toContain(DEFAULT_PARTICIPANT_AUDIO_LABELS.audioUnavailable)
+  })
+})
+
+describe('recorder review reuses the same player', () => {
+  it('draws the player with the object URL, hands the audio element to the recorder ref and shows the recorded duration', () => {
+    const audioRef: { current: HTMLAudioElement | null } = { current: null }
+    kit.container = kit.harness.mount(
+      <ParticipantAudioRecorderView state="review" elapsedMs={0} review={{ url: 'blob:fake', audioRef, durationMs: 12_000 }} />,
+    ).container
+    expect(kit.container.querySelector('.cv-p-audio')).not.toBeNull()
+    expect(audioOf().getAttribute('src')).toBe('blob:fake')
+    expect(audioOf().getAttribute('preload')).toBe('none')
+    expect(audioRef.current).toBe(audioOf())
+    expect(find('.cv-p-audio__time').textContent).toBe('0:00 / 0:12')
+  })
+})

package/src/participant/participantAudioPlayerCss.test.ts

@@ -0,0 +1,63 @@
+import { readdirSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+import { describe, expect, it } from 'bun:test'
+
+import { declarationsIn, mediaBody, PARTICIPANT_CSS } from './participantCss.test-helper'
+
+describe('player styles (.cv-p-audio*)', () => {
+  it('keeps both buttons and the bar at the touch size, from the existing tokens', () => {
+    for (const selector of ['.cv-p-audio__seek']) expect(declarationsIn(selector).get('min-height')).toBe('var(--cv-p-i-touch)')
+    expect(PARTICIPANT_CSS).toContain('min-width: var(--cv-p-i-touch); min-height: var(--cv-p-i-touch)')
+  })
+
+  it('has a width floor that never exceeds the bubble, so the play button stays visible at 375 px', () => {
+    expect(declarationsIn('.cv-p-audio').get('min-width')).toBe('min(15rem, 100%)')
+  })
+
+  it('does not draw the media element and defines no utility-class dependency', () => {
+    expect(declarationsIn('.cv-p-audio__media').get('display')).toBe('none')
+    expect(PARTICIPANT_CSS).not.toMatch(/@apply|\btw-/)
+  })
+})
+
+describe('transcription styles (.cv-p-transcription*)', () => {
+  it('clamps the text at six lines and keeps it selectable', () => {
+    const text = declarationsIn('.cv-p-transcription__text')
+    expect(text.get('-webkit-line-clamp')).toBe('6')
+    expect(text.get('user-select')).toBe('text')
+    expect(declarationsIn(".cv-p-transcription__text[data-expanded='true']").get('overflow')).toBe('visible')
+  })
+
+  it('gives the see-all button the touch size and a forced-colors outline, from existing tokens', () => {
+    const toggle = declarationsIn('.cv-p-transcription__toggle')
+    expect(toggle.get('min-height')).toBe('var(--cv-p-i-touch)')
+    expect(toggle.get('min-width')).toBe('var(--cv-p-i-touch)')
+    expect(mediaBody('(forced-colors: active)')).toContain('.cv-p-transcription__toggle')
+  })
+
+  it('has no motion, so reduced-motion is respected by construction', () => {
+    expect(PARTICIPANT_CSS).not.toMatch(/\.cv-p-transcription[^{]*\{[^}]*(transition|animation)/)
+  })
+
+  it('uses only existing tokens and no utility-class dependency', () => {
+    const rules = PARTICIPANT_CSS.split('\n').filter((line) => line.startsWith('.cv-p-transcription'))
+    expect(rules.length).toBeGreaterThan(5)
+    for (const variable of rules.join('\n').match(/var\(--cv-p-i-[a-z-]+\)/g) ?? []) {
+      expect(PARTICIPANT_CSS).toContain(`${variable.slice(4, -1)}:`)
+    }
+    expect(rules.join('\n')).not.toMatch(/@apply|\btw-/)
+  })
+})
+
+describe('no dead audio selectors', () => {
+  it('every .cv-p-recorder*, .cv-p-audio* and .cv-p-transcription* class is rendered by a component', () => {
+    const sources = readdirSync(import.meta.dir)
+      .filter((name) => name.endsWith('.tsx') && !name.includes('.test'))
+      .map((name) => readFileSync(join(import.meta.dir, name), 'utf8'))
+      .join('\n')
+    const classNames = new Set(PARTICIPANT_CSS.match(/\.cv-p-(?:recorder|audio|transcription)[a-z_-]*/g) ?? [])
+    expect(classNames.size).toBeGreaterThan(10)
+    for (const selector of classNames) expect(sources).toContain(selector.slice(1))
+  })
+})

package/src/participant/participantAudioPlayerDom.test.tsx

@@ -0,0 +1,154 @@
+import { act, useState } from 'react'
+
+import type { ParticipantAttachment } from '@adatechnology/conversation-contracts'
+import { afterEach, describe, expect, it } from 'bun:test'
+
+import { wait } from '../domHarness.test-helper'
+import { ATTACHMENT_URL_RETRY_DELAY_MS } from './useStableAttachmentUrl'
+import { ParticipantAudioAttachment } from './ParticipantAudioAttachment'
+import { DEFAULT_PARTICIPANT_AUDIO_LABELS } from './participantAudioLabels'
+import { buildAttachment, setupPlayerDom } from './participantAudioPlayerDomKit.test-helper'
+import { DEFAULT_PARTICIPANT_CONVERSATIONS_LABELS } from './participantLabels'
+
+const kit = setupPlayerDom()
+const { mountAttachments, audioOf, toggleOf, find, tap } = kit
+
+const realSetTimeout = globalThis.setTimeout
+const SETTLE_MS = 20
+let heldRetries: Array<() => void> = []
+
+/** Holds the retry timers (1 s) instead of sleeping: the test fires them on demand, with no wall-clock margin. */
+function holdRetryTimers(): void {
+  heldRetries = []
+  const shim = ((handler: TimerHandler, delay?: number, ...args: unknown[]) => {
+    if (delay !== ATTACHMENT_URL_RETRY_DELAY_MS) return realSetTimeout(handler, delay, ...args)
+    heldRetries.push(() => (handler as () => void)())
+    return 0
+  }) as unknown as typeof setTimeout
+  globalThis.setTimeout = shim
+}
+
+async function fireHeldRetries(): Promise<void> {
+  const pending = heldRetries
+  heldRetries = []
+  for (const retry of pending) retry()
+  await wait(SETTLE_MS)
+}
+
+afterEach(() => {
+  globalThis.setTimeout = realSetTimeout
+})
+
+describe('source: resolved at mount by id, never downloaded before the tap', () => {
+  it('assigns the resolved src with preload="none" and resolves once', async () => {
+    await mountAttachments([buildAttachment('a')])
+    expect(audioOf().getAttribute('src')).toBe('https://files.test/a-1.webm')
+    expect(audioOf().getAttribute('preload')).toBe('none')
+    expect(audioOf().hasAttribute('controls')).toBe(false)
+    expect(kit.resolverCalls).toEqual(['a'])
+    expect(kit.media.playCalls).toHaveLength(0)
+  })
+
+  it('a list update with a new attachment object and a new URL does not resolve again nor change the src', async () => {
+    let setAttachment: (attachment: ParticipantAttachment) => void = () => undefined
+    function Harness() {
+      const [attachment, update] = useState(buildAttachment('a'))
+      setAttachment = update
+      return <ParticipantAudioAttachment attachment={attachment} resolveAttachmentUrl={(item) => kit.resolveAttachmentUrl(item)} labels={DEFAULT_PARTICIPANT_CONVERSATIONS_LABELS} />
+    }
+    kit.container = kit.harness.mount(<Harness />).container
+    await wait(0)
+    tap(toggleOf())
+    kit.media.stateOf(audioOf()).currentTime = 20
+    act(() => setAttachment(buildAttachment('a', 65_000)))
+    await wait(0)
+    expect(kit.resolverCalls).toEqual(['a'])
+    expect(audioOf().getAttribute('src')).toBe('https://files.test/a-1.webm')
+    expect(kit.media.stateOf(audioOf()).currentTime).toBe(20)
+    expect(kit.media.stateOf(audioOf()).paused).toBe(false)
+  })
+
+  it('shows the unavailable state when the URL cannot be resolved after the second attempt', async () => {
+    holdRetryTimers()
+    await mountAttachments([buildAttachment('a')], async () => {
+      throw new Error('nope')
+    })
+    await fireHeldRetries()
+    expect(kit.container.textContent).toContain(DEFAULT_PARTICIPANT_AUDIO_LABELS.audioUnavailable)
+    expect(audioOf().hasAttribute('src')).toBe(false)
+  })
+
+  it('a transient failure of the first resolution gets one new attempt before giving up', async () => {
+    {
+      holdRetryTimers()
+      let attempts = 0
+      await mountAttachments([buildAttachment('a')], async () => {
+        attempts += 1
+        if (attempts === 1) throw new Error('offline for a moment')
+        return 'https://files.test/a-retry.webm'
+      })
+      expect(audioOf().hasAttribute('src')).toBe(false)
+      expect(kit.container.querySelector('.cv-p-audio__error')).toBeNull()
+      await fireHeldRetries()
+      expect(attempts).toBe(2)
+      expect(audioOf().getAttribute('src')).toBe('https://files.test/a-retry.webm')
+      expect(kit.container.querySelector('.cv-p-audio__error')).toBeNull()
+    }
+  })
+
+  it('says it with static text: no alert role (N failing players would be N assertive announcements) and a disabled toggle', async () => {
+    holdRetryTimers()
+    await mountAttachments([buildAttachment('a'), buildAttachment('b')], async () => {
+      throw new Error('nope')
+    })
+    await fireHeldRetries()
+    const messages = kit.container.querySelectorAll('.cv-p-audio__error')
+    expect(messages).toHaveLength(2)
+    for (const message of Array.from(messages)) expect(message.hasAttribute('role')).toBe(false)
+    expect(kit.container.querySelector('[role="alert"]')).toBeNull()
+    expect(toggleOf().disabled).toBe(true)
+  })
+
+  it('puts the file name after the player', async () => {
+    await mountAttachments([buildAttachment('a')])
+    const wrapper = find('.cv-p-attachment--audio')
+    expect(wrapper.firstElementChild?.className).toBe('cv-p-audio')
+    expect(wrapper.lastElementChild?.className).toBe('cv-p-attachment__name')
+    expect(kit.container.querySelector('.cv-p-attachment__audio')).toBeNull()
+  })
+})
+
+describe('play and pause', () => {
+  it('calls play() synchronously in the tap (a play after an await loses the iOS gesture)', async () => {
+    await mountAttachments([buildAttachment('a')])
+    tap(toggleOf())
+    expect(kit.media.playCalls).toHaveLength(1)
+    expect(kit.media.playCalls[0] === audioOf()).toBe(true)
+    expect(toggleOf().getAttribute('aria-label')).toBe('Pause audio')
+    tap(toggleOf())
+    expect(toggleOf().getAttribute('aria-label')).toBe('Play audio')
+  })
+
+  it('stays on "Play audio" when the browser refuses play()', async () => {
+    await mountAttachments([buildAttachment('a')])
+    kit.media.playOutcome = 'reject'
+    tap(toggleOf())
+    await wait(0)
+    expect(toggleOf().getAttribute('aria-label')).toBe('Play audio')
+  })
+
+  it('playing one audio pauses the other', async () => {
+    await mountAttachments([buildAttachment('a'), buildAttachment('b')])
+    tap(toggleOf(0))
+    tap(toggleOf(1))
+    expect(kit.media.pauseCalls).toHaveLength(1)
+    expect(kit.media.pauseCalls[0] === audioOf(0)).toBe(true)
+    expect(toggleOf(0).getAttribute('aria-label')).toBe('Play audio')
+    expect(toggleOf(1).getAttribute('aria-label')).toBe('Pause audio')
+  })
+
+  it('the toggle is at least the touch size and a plain button', async () => {
+    await mountAttachments([buildAttachment('a')])
+    expect(toggleOf().getAttribute('type')).toBe('button')
+  })
+})

package/src/participant/participantAudioPlayerDomKit.test-helper.tsx

@@ -0,0 +1,84 @@
+import { act } from 'react'
+
+import type { ParticipantAttachment } from '@adatechnology/conversation-contracts'
+import { afterAll, afterEach, beforeAll, beforeEach } from 'bun:test'
+
+import { setupDom, wait, type DomHarness } from '../domHarness.test-helper'
+import { ParticipantAudioAttachment } from './ParticipantAudioAttachment'
+import { DEFAULT_PARTICIPANT_CONVERSATIONS_LABELS } from './participantLabels'
+import { installFakeMedia, type FakeMediaControls } from './participantMediaFakes.test-helper'
+
+export type PlayerDomKit = {
+  harness: DomHarness
+  media: FakeMediaControls
+  container: HTMLElement
+  resolverCalls: string[]
+  urlSequence: string[]
+  resolveAttachmentUrl: (attachment: ParticipantAttachment) => Promise<string>
+  mountAttachments: (attachments: ParticipantAttachment[], resolver?: PlayerDomKit['resolveAttachmentUrl']) => Promise<void>
+  audioOf: (index?: number) => HTMLAudioElement
+  toggleOf: (index?: number) => HTMLButtonElement
+  find: <TElement extends Element>(selector: string) => TElement
+  tap: (element: Element) => void
+}
+
+export function buildAttachment(id: string, durationMs?: number): ParticipantAttachment {
+  return { id, kind: 'audio', filename: `${id}.webm`, mimeType: 'audio/webm', sizeBytes: 2048, ...(durationMs === undefined ? {} : { durationMs }) } as ParticipantAttachment
+}
+
+export function setupPlayerDom(): PlayerDomKit {
+  const kit: PlayerDomKit = {
+    resolveAttachmentUrl: async (attachment) => {
+      kit.resolverCalls.push(attachment.id)
+      const url = kit.urlSequence[kit.resolverCalls.filter((id) => id === attachment.id).length - 1]
+      if (!url) throw new Error('unavailable')
+      return attachment.id === 'b' ? 'https://files.test/b-1.webm' : url
+    },
+    mountAttachments: async (attachments, resolver = kit.resolveAttachmentUrl) => {
+      kit.container = kit.harness.mount(
+        <>
+          {attachments.map((attachment) => (
+            <ParticipantAudioAttachment key={attachment.id} attachment={attachment} resolveAttachmentUrl={resolver} labels={DEFAULT_PARTICIPANT_CONVERSATIONS_LABELS} />
+          ))}
+        </>,
+      ).container
+      await wait(0)
+    },
+    audioOf: (index = 0) => {
+      const audio = kit.container.querySelectorAll<HTMLAudioElement>('audio')[index]
+      if (!audio) throw new Error('missing audio')
+      return audio
+    },
+    toggleOf: (index = 0) => {
+      const toggle = kit.container.querySelectorAll<HTMLButtonElement>('.cv-p-audio__toggle')[index]
+      if (!toggle) throw new Error('missing toggle')
+      return toggle
+    },
+    find: <TElement extends Element>(selector: string): TElement => {
+      const element = kit.container.querySelector<TElement>(selector)
+      if (!element) throw new Error(`missing ${selector}`)
+      return element
+    },
+    tap: (element) => {
+      act(() => {
+        element.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true }))
+      })
+    },
+  } as PlayerDomKit
+
+  beforeAll(async () => {
+    kit.harness = await setupDom()
+  })
+
+  afterAll(() => kit.harness.teardown())
+
+  beforeEach(() => {
+    kit.media = installFakeMedia()
+    kit.resolverCalls = []
+    kit.urlSequence = ['https://files.test/a-1.webm', 'https://files.test/a-2.webm', 'https://files.test/a-3.webm']
+  })
+
+  afterEach(() => kit.media.restore())
+
+  return kit
+}

package/src/participant/participantAudioPlayerState.ts

@@ -0,0 +1,35 @@
+import type { MutableRefObject } from 'react'
+
+import type { AudioPlaybackHandle } from './participantAudioCoordinator'
+import { PLAYBACK_RATES } from './participantAudioFormat'
+
+export type PlayerState = {
+  readonly isPlaying: boolean
+  readonly position: number
+  readonly mediaDuration: number | undefined
+  readonly maxSeen: number
+  readonly rateIndex: number
+  readonly hasFailed: boolean
+}
+
+export const INITIAL_PLAYER_STATE: PlayerState = {
+  isPlaying: false,
+  position: 0,
+  mediaDuration: undefined,
+  maxSeen: 0,
+  rateIndex: 0,
+  hasFailed: false,
+}
+
+export type PlayerContext = {
+  readonly audioRef: MutableRefObject<HTMLAudioElement | null>
+  readonly handleRef: MutableRefObject<AudioPlaybackHandle>
+  readonly state: PlayerState
+  readonly update: (patch: Partial<PlayerState>) => void
+}
+
+export function applyPlaybackRate(audio: HTMLAudioElement, rateIndex: number): void {
+  const rate = PLAYBACK_RATES[rateIndex] ?? 1
+  audio.defaultPlaybackRate = rate
+  audio.playbackRate = rate
+}

package/src/participant/participantAudioRecorderDom.test.tsx

@@ -0,0 +1,127 @@
+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 } = kit
+
+describe('the happy path', () => {
+  it('goes idle -> requesting -> recording -> review with a coherent File', async () => {
+    mountProbe()
+    expect(kit.api.status).toBe('idle')
+    deferStream()
+    await start()
+    expect(kit.api.status).toBe('requesting')
+    await act(async () => kit.resolveStream?.(kit.stream))
+    expect(kit.api.status).toBe('recording')
+    await advance(1500)
+    act(() => kit.api.stop())
+    expect(kit.api.status).toBe('review')
+    expect(kit.api.recorded?.file.type).toBe('audio/ogg')
+    expect(kit.api.recorded?.file.name).toMatch(/^audio-\d{8}-\d{6}\.ogg$/)
+    expect(kit.api.recorded?.file.size).toBe(4096)
+    expect(kit.api.recorded?.objectUrl).toBe('blob:fake-recording')
+    expect(kit.stream.track.stopCount).toBeGreaterThan(0)
+  })
+
+  it('falls back to m4a with the matching mime type', async () => {
+    kit.supportedTypes = ['audio/mp4']
+    mountProbe()
+    await recordFor(1000)
+    act(() => kit.api.stop())
+    expect(kit.api.recorded?.file.name).toMatch(/\.m4a$/)
+    expect(kit.api.recorded?.file.type).toBe('audio/mp4')
+  })
+
+  it('reports capture from requesting until it leaves review, and revokes the URL on every exit', async () => {
+    mountProbe()
+    await recordFor(1000)
+    act(() => kit.api.stop())
+    expect(kit.captureEvents).toEqual([true])
+    let file: File | undefined
+    act(() => {
+      file = kit.api.confirm()
+    })
+    expect(file?.size).toBe(4096)
+    expect(kit.api.status).toBe('idle')
+    expect(kit.revoked).toEqual(['blob:fake-recording'])
+    expect(kit.captureEvents).toEqual([true, false])
+  })
+
+  it('discard from review revokes the URL and returns to idle', async () => {
+    mountProbe()
+    await recordFor(1000)
+    act(() => kit.api.stop())
+    act(() => kit.api.discard())
+    expect(kit.api.status).toBe('idle')
+    expect(kit.revoked).toEqual(['blob:fake-recording'])
+  })
+
+  it('discard while recording stops the track and records nothing', async () => {
+    mountProbe()
+    await recordFor(1000)
+    act(() => kit.api.discard())
+    expect(kit.api.status).toBe('idle')
+    expect(kit.stream.track.stopCount).toBeGreaterThan(0)
+    expect(kit.api.recorded).toBeUndefined()
+  })
+})
+
+describe('failures', () => {
+  it('permission denied -> denied, and the next tap asks again', async () => {
+    kit.getUserMediaImpl = () => Promise.reject(Object.assign(new Error('x'), { name: 'NotAllowedError' }))
+    mountProbe()
+    await start()
+    expect(kit.api.status).toBe('denied')
+    kit.getUserMediaImpl = async () => kit.stream
+    await start()
+    expect(kit.api.status).toBe('recording')
+  })
+
+  it('no microphone device -> unsupported', async () => {
+    kit.getUserMediaImpl = () => Promise.reject(Object.assign(new Error('x'), { name: 'NotFoundError' }))
+    mountProbe()
+    await start()
+    expect(kit.api.status).toBe('unsupported')
+  })
+
+  it('no MediaRecorder at all -> unsupported without asking for the microphone', async () => {
+    delete (globalThis as Record<string, unknown>).MediaRecorder
+    let asked = false
+    kit.getUserMediaImpl = async () => {
+      asked = true
+      return kit.stream
+    }
+    mountProbe()
+    await start()
+    expect(kit.api.status).toBe('unsupported')
+    expect(asked).toBe(false)
+  })
+
+  it('a recording with no bytes -> empty, tracks released', async () => {
+    kit.chunkBytes = 0
+    mountProbe()
+    await recordFor(1000)
+    act(() => kit.api.stop())
+    expect(kit.api.status).toBe('empty')
+    expect(kit.stream.track.stopCount).toBeGreaterThan(0)
+    expect(kit.revoked).toEqual([])
+  })
+
+  it('stopping before the minimum duration -> empty', async () => {
+    mountProbe()
+    await recordFor(100)
+    act(() => kit.api.stop())
+    expect(kit.api.status).toBe('empty')
+  })
+
+  it('above the byte ceiling -> tooLarge, nothing kept', async () => {
+    mountProbe({ maxSizeBytes: 1000 })
+    await recordFor(1000)
+    act(() => kit.api.stop())
+    expect(kit.api.status).toBe('tooLarge')
+    expect(kit.api.recorded).toBeUndefined()
+  })
+})