@recombine-ai/bosun 0.16.2 → 0.18.0

package/src/backend/tests/test-history-edit-proposals.ts

@@ -0,0 +1,69 @@
+import { randomUUID } from 'node:crypto'
+
+export interface TestHistoryEditProposal {
+	id: string
+	agentId: string
+	region: string | null
+	testId: string
+	step: string
+	originalConversation: string
+	suggestedConversation: string
+	expectedOutput: string
+	createdAt: number
+}
+
+export interface TestHistoryEditSourceGuard {
+	suiteKey: string
+	allowedTestFingerprints: string[]
+	allowedPromptContents: string[]
+}
+
+type StoredTestHistoryEditProposal = TestHistoryEditProposal & {
+	sourceGuard: TestHistoryEditSourceGuard
+}
+
+const proposals = new Map<string, StoredTestHistoryEditProposal>()
+const PROPOSAL_TTL_MS = 12 * 60 * 60 * 1000
+
+export function createTestHistoryEditProposal(
+	proposal: Omit<TestHistoryEditProposal, 'id' | 'createdAt'> & {
+		sourceGuard: TestHistoryEditSourceGuard
+	}
+): TestHistoryEditProposal {
+	removeExpiredTestHistoryEditProposals()
+	const stored = { ...proposal, id: randomUUID(), createdAt: Date.now() }
+	proposals.set(stored.id, stored)
+	return publicProposal(stored)
+}
+
+export function getTestHistoryEditProposalForAcceptance(
+	id: string
+): StoredTestHistoryEditProposal | null {
+	removeExpiredTestHistoryEditProposals()
+	const proposal = proposals.get(id)
+	return proposal
+		? {
+				...proposal,
+				sourceGuard: {
+					suiteKey: proposal.sourceGuard.suiteKey,
+					allowedTestFingerprints: [...proposal.sourceGuard.allowedTestFingerprints],
+					allowedPromptContents: [...proposal.sourceGuard.allowedPromptContents]
+				}
+			}
+		: null
+}
+
+export function deleteTestHistoryEditProposal(id: string): boolean {
+	return proposals.delete(id)
+}
+
+function removeExpiredTestHistoryEditProposals(now = Date.now()) {
+	for (const [id, proposal] of proposals) {
+		if (proposal.createdAt + PROPOSAL_TTL_MS <= now) proposals.delete(id)
+	}
+}
+
+function publicProposal(proposal: StoredTestHistoryEditProposal): TestHistoryEditProposal {
+	const { sourceGuard: _sourceGuard, ...result } = proposal
+	return { ...result }
+}

package/src/backend/tests/test-history-overrides.spec.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it } from 'vitest'
+
+import { applyTestHistoryOverrides } from './academy'
+
+describe('applyTestHistoryOverrides', () => {
+	it('changes only the targeted test in memory', () => {
+		const first = { id: 'first', conversation: 'User: old', expected_output: 'Expected one' }
+		const second = {
+			id: 'second',
+			conversation: 'User: untouched',
+			expected_output: 'Expected two'
+		}
+
+		const result = applyTestHistoryOverrides([first, second], {
+			first: { conversation: 'User: proposed' }
+		})
+
+		expect(result).toEqual([
+			{ id: 'first', conversation: 'User: proposed', expected_output: 'Expected one' },
+			second
+		])
+		expect(first.conversation).toBe('User: old')
+	})
+})

package/src/backend/tests/test-selection.ts

@@ -0,0 +1,27 @@
+import { getProjectBosunApi } from '../lib/project-api'
+
+export interface SuiteSelection {
+	suiteKey: string
+	agentId: string
+	region?: string
+}
+
+export async function resolveSuiteSelection(
+	agentId: string,
+	region?: string | null
+): Promise<SuiteSelection> {
+	const bosunApi = await getProjectBosunApi()
+	const meta = bosunApi ? await bosunApi.getAgentMeta(agentId) : null
+	if (meta?.testScope !== 'region') return { suiteKey: agentId, agentId }
+
+	if (!bosunApi) {
+		throw new Error(`Project does not export bosunApi, cannot resolve suite for '${agentId}'.`)
+	}
+
+	const resolved = await bosunApi.resolveTestSuite({ agentId, region })
+	return {
+		suiteKey: resolved.suiteKey,
+		agentId,
+		region: resolved.resolvedRegion ?? undefined
+	}
+}

package/src/lib/api-telescope/client.ts

@@ -80,6 +80,19 @@ export class TelescopeClient {
 			searchParams.append('lastConversationId', params.lastConversationId)
 		if (params.phoneNumber) searchParams.append('phoneNumber', params.phoneNumber)
 		if (params.agentId) searchParams.append('agentId', params.agentId)
+		if (params.analyticsFilters?.length) {
+			searchParams.append(
+				'filters',
+				JSON.stringify(
+					params.analyticsFilters.map((filter) => ({
+						key: filter.key,
+						type: filter.type,
+						operator: 'in',
+						values: filter.values
+					}))
+				)
+			)
+		}
 
 		const res = await this.fetch('GET', `/conversations?${searchParams.toString()}`)
 		if (!res.ok) {
@@ -100,6 +113,18 @@ export class TelescopeClient {
 		return types.PaginatedConversationsResponseSchema.parse(json)
 	}
 
+	public async getAnalyticsFields(agentId?: string): Promise<types.AnalyticsFieldsResponse> {
+		const searchParams = new URLSearchParams()
+		if (agentId) searchParams.set('agentId', agentId)
+		const query = searchParams.toString()
+
+		return this.fetch(
+			'GET',
+			`/analytics/fields${query ? `?${query}` : ''}`,
+			types.AnalyticsFieldsResponseSchema
+		)
+	}
+
 	/**
 	 * Get a single conversation by ID
 	 * @param conversationId the conversation ID

package/src/lib/api-telescope/source-selection.spec.ts

@@ -0,0 +1,44 @@
+import { describe, expect, it } from 'vitest'
+import {
+	getTelescopeSourceIdFromUrl,
+	resolveTelescopeSourceId,
+	withTelescopeSourceId
+} from './source-selection'
+
+const sources = [{ id: 'prod' }, { id: 'staging' }]
+
+describe('Telescope source URLs', () => {
+	it('uses a valid source from the URL before the persisted source', () => {
+		expect(resolveTelescopeSourceId(sources, 'staging', 'prod')).toBe('staging')
+	})
+
+	it('keeps links without a source on the persisted source', () => {
+		expect(resolveTelescopeSourceId(sources, null, 'staging')).toBe('staging')
+	})
+
+	it('uses the first source when a link and persisted source have no valid source', () => {
+		expect(resolveTelescopeSourceId(sources, null, null)).toBe('prod')
+		expect(resolveTelescopeSourceId(sources, 'unknown', 'missing')).toBe('prod')
+	})
+
+	it('reads only non-empty source IDs from URLs', () => {
+		expect(getTelescopeSourceIdFromUrl(new URL('http://localhost/view?source=staging'))).toBe(
+			'staging'
+		)
+		expect(getTelescopeSourceIdFromUrl(new URL('http://localhost/view?source=%20'))).toBeNull()
+	})
+
+	it('adds the source without changing the trace path or other query parameters', () => {
+		const original = new URL(
+			'http://localhost/view/conversations/call-1/traces?agent=booking&region=uk'
+		)
+		const result = withTelescopeSourceId(original, 'staging/eu')
+
+		expect(result.pathname).toBe('/view/conversations/call-1/traces')
+		expect(result.searchParams.get('agent')).toBe('booking')
+		expect(result.searchParams.get('region')).toBe('uk')
+		expect(result.searchParams.get('source')).toBe('staging/eu')
+		expect(result.search).toContain('source=staging%2Feu')
+		expect(original.searchParams.has('source')).toBe(false)
+	})
+})

package/src/lib/api-telescope/source-selection.ts

@@ -1,4 +1,32 @@
 export const TELESCOPE_SOURCE_STORAGE_KEY = 'bosun.traces.telescopeSourceId'
+export const TELESCOPE_SOURCE_QUERY_PARAM = 'source'
+
+type TelescopeSource = { id: string }
+
+export function getTelescopeSourceIdFromUrl(url: URL): string | null {
+	const sourceId = url.searchParams.get(TELESCOPE_SOURCE_QUERY_PARAM)?.trim()
+	return sourceId || null
+}
+
+export function resolveTelescopeSourceId(
+	sources: readonly TelescopeSource[],
+	requestedSourceId: string | null,
+	persistedSourceId: string | null
+): string | null {
+	const requested = requestedSourceId?.trim()
+	if (requested && sources.some((source) => source.id === requested)) return requested
+
+	const persisted = persistedSourceId?.trim()
+	if (persisted && sources.some((source) => source.id === persisted)) return persisted
+
+	return sources[0]?.id ?? null
+}
+
+export function withTelescopeSourceId(url: URL, sourceId: string): URL {
+	const nextUrl = new URL(url)
+	nextUrl.searchParams.set(TELESCOPE_SOURCE_QUERY_PARAM, sourceId)
+	return nextUrl
+}
 
 export function getPersistedTelescopeSourceId(): string | null {
 	if (typeof window === 'undefined') return null

package/src/lib/api-telescope/types.ts

@@ -30,9 +30,37 @@ export const PaginatedConversationsResponseSchema = z.object({
 
 export type PaginatedConversationsResponse = z.infer<typeof PaginatedConversationsResponseSchema>
 
+export const AnalyticsScalarSchema = z.union([z.boolean(), z.number(), z.string()])
+export type AnalyticsScalar = z.infer<typeof AnalyticsScalarSchema>
+
+export const AnalyticsFieldSchema = z.object({
+	key: z.string(),
+	type: z.enum(['boolean', 'number', 'string']),
+	variantCount: z.number(),
+	values: z.array(
+		z.object({
+			value: AnalyticsScalarSchema,
+			count: z.number()
+		})
+	)
+})
+export type AnalyticsField = z.infer<typeof AnalyticsFieldSchema>
+
+export const AnalyticsFieldsResponseSchema = z.object({
+	items: z.array(AnalyticsFieldSchema)
+})
+export type AnalyticsFieldsResponse = z.infer<typeof AnalyticsFieldsResponseSchema>
+
+export type AnalyticsConversationFilter = {
+	key: string
+	type: AnalyticsField['type']
+	values: AnalyticsScalar[]
+}
+
 export type GetConversationsRequest = {
 	phoneNumber?: string
 	agentId?: string
+	analyticsFilters?: AnalyticsConversationFilter[]
 	limit?: number
 	lastConversationId?: string
 }

package/src/lib/components/Modal.svelte

@@ -47,7 +47,7 @@
 			</div>
 			{#if underlayOpen && underlay}
 				<div
-					class="modal-underlay absolute left-0 right-0 top-full -z-10 overflow-hidden rounded-b-lg border border-t-0 border-rc-gray-600 bg-rc-gray-800 px-4 py-2.5 shadow-xl"
+					class="modal-underlay absolute left-0 right-0 top-full -z-10 -mt-2 overflow-hidden rounded-b-lg border border-t-0 border-rc-gray-600 bg-rc-gray-800 px-4 pb-1 pt-3 shadow-xl"
 				>
 					{@render underlay()}
 				</div>

package/src/lib/components/Tab.svelte

@@ -1,5 +1,5 @@
 <script lang="ts">
-	import { getContext, onMount, onDestroy } from 'svelte'
+	import { getContext, onMount } from 'svelte'
 	import type { Snippet } from 'svelte'
 	import type { Readable } from 'svelte/store'
 
@@ -22,8 +22,8 @@
 	}: Props = $props()
 
 	const uid = Math.random().toString(36).slice(2, 8)
-	if (!id) id = `tab-${uid}`
-	if (!value) value = id
+	const tabId = $derived(id || `tab-${uid}`)
+	const tabValue = $derived(value || tabId)
 
 	let btnEl: HTMLButtonElement | null = $state(null)
 
@@ -35,19 +35,17 @@
 	}>('rc-tabs')
 
 	const valueStore = tabs.value
-	let selected = $derived($valueStore === value)
+	let selected = $derived($valueStore === tabValue)
 
 	onMount(() => {
-		tabs?.register({ id, value, getEl: () => btnEl })
-	})
-
-	onDestroy(() => {
-		tabs?.unregister(id)
+		const registeredId = tabId
+		tabs?.register({ id: registeredId, value: tabValue, getEl: () => btnEl })
+		return () => tabs?.unregister(registeredId)
 	})
 
 	function handleClick(e: MouseEvent) {
 		if (disabled) return
-		tabs?.requestSelect(value)
+		tabs?.requestSelect(tabValue)
 		onclick?.(e)
 	}
 </script>
@@ -59,9 +57,9 @@
 	class:active={selected}
 	{disabled}
 	role="tab"
-	{id}
+	id={tabId}
 	aria-selected={selected}
-	aria-controls={`panel-${value}`}
+	aria-controls={`panel-${tabValue}`}
 	tabindex={selected ? 0 : -1}
 	onclick={handleClick}
 >

package/src/lib/edit/edit-workspace-context.ts

@@ -13,6 +13,32 @@ export interface PendingPromptEdit {
 	createdAt: number
 }
 
+export interface PendingTestHistoryEdit {
+	id: string
+	agentId: string
+	region: string | null
+	testId: string
+	step: string
+	originalConversation: string
+	suggestedConversation: string
+	expectedOutput: string
+	createdAt: number
+}
+
+export interface TestAiEditTarget {
+	kind: 'test-history' | 'test-fix'
+	testId: string
+	step: string
+	prompt: string
+	basePrompt: string
+	conversation: string
+	expectedOutput: string
+	context: string
+	assertionLabel: string
+	assertionValue: string
+	currentIncorrectOutcome?: string
+}
+
 export interface EditWorkspaceState {
 	agentId: string
 	region: string | null
@@ -26,6 +52,7 @@ export interface EditWorkspaceState {
 	currentStep: StepDef | null
 	promptDrafts: Record<string, string>
 	promptEdits: Record<string, PendingPromptEdit>
+	testHistoryEdits: Record<string, PendingTestHistoryEdit>
 	context: Record<string, any> | null
 	promptContext: Record<string, any> | null
 	agentStates: AgentSateHeader[]
@@ -48,6 +75,7 @@ export interface EditWorkspaceActions {
 	openContextPopover: () => void
 	closeContextPopover: () => void
 	toggleContextPopover: () => void
+	openAiEdit: (request: string, target?: TestAiEditTarget) => void
 
 	// WS actions
 	sendAppEvent: (event: AppEvent) => void
@@ -55,6 +83,7 @@ export interface EditWorkspaceActions {
 	selectState: (stateId: string | null) => void
 	flushPromptSave: () => Promise<void>
 	getPromptOverrides: () => Record<string, string>
+	getTestHistoryOverrides: () => Record<string, { conversation: string }>
 	getActivePromptEditId: () => string | null
 	hangup: () => void
 }

package/src/lib/edit/test-ai-edit.spec.ts

@@ -0,0 +1,31 @@
+import { describe, expect, it } from 'vitest'
+
+import { buildPromptFixRequest, buildTestFixRequest } from './test-ai-edit'
+
+const input = {
+	context: '{}',
+	conversation: 'User: corrected',
+	expectedOutput: 'Agent: expected',
+	assertionLabel: 'LLM',
+	assertionValue: 'Matches the expected behaviour',
+	currentIncorrectOutcome: 'Agent: wrong'
+}
+
+describe('buildPromptFixRequest', () => {
+	it('rebuilds the standard request with the corrected conversation', () => {
+		const entered = buildTestFixRequest({ ...input, conversation: 'User: original' })
+
+		const result = buildPromptFixRequest(entered, input, 'User: original')
+
+		expect(result).toContain('Conversation:\nUser: corrected')
+		expect(result).not.toContain('Conversation:\nUser: original')
+	})
+
+	it('retains a customized request and appends the authoritative corrected test', () => {
+		const result = buildPromptFixRequest('Keep this custom instruction.', input, 'User: original')
+
+		expect(result).toContain('Keep this custom instruction.')
+		expect(result).toContain('Use the following test case as authoritative')
+		expect(result).toContain('Conversation:\nUser: corrected')
+	})
+})

package/src/lib/edit/test-ai-edit.ts

@@ -0,0 +1,52 @@
+export interface TestFixRequestInput {
+	context: string
+	conversation: string
+	expectedOutput: string
+	assertionLabel: string
+	assertionValue: string
+	currentIncorrectOutcome: string
+}
+
+export const UPDATE_HISTORY_REQUEST = `Update the conversation history so it reflects behaviour that is valid under the current prompt. Preserve the test's intent and expected outcome, and make only the smallest necessary changes. Possible roles: "Agent", "User", "System"`
+
+export function formatTestFixAssertion(label: string, value: string): string {
+	const normalizedLabel = label.trim() === 'LLM' ? '' : label.trim()
+	return [normalizedLabel, value.trim()].filter(Boolean).join(' ')
+}
+
+export function buildTestFixRequest(input: TestFixRequestInput): string {
+	const assertion = formatTestFixAssertion(input.assertionLabel, input.assertionValue)
+
+	return `You will be given the context, the conversation and the desired output and assertion about it. First, find why the prompt is not producing the correct result. It's usually one concrete instruction within the relevant section, or a contradiction. Then, change the prompt minimally so this will work, but keeping the prompt clean and comprehensive is more important. Try to provide as general solution as possible. Try to change just one part of the prompt, not multiple parts. Avoid adding exceptions and overrides. Avoid duplicating information that already exists in the prompt.
+
+Context:
+${input.context.trim()}
+
+Conversation:
+${input.conversation.trim()}
+
+Desired outcome:
+${input.expectedOutput.trim()}
+
+Assertion about outcome:
+${assertion}
+
+Current incorrect outcome:
+${input.currentIncorrectOutcome.trim()}`
+}
+
+export function buildPromptFixRequest(
+	enteredRequest: string,
+	input: TestFixRequestInput,
+	originalConversation: string
+): string {
+	const canonicalOriginal = buildTestFixRequest({ ...input, conversation: originalConversation })
+	const canonicalCorrected = buildTestFixRequest(input)
+	if (enteredRequest.trim() === canonicalOriginal.trim()) return canonicalCorrected
+
+	return `${enteredRequest.trim()}
+
+The conversation history has now been checked and may have been corrected. Use the following test case as authoritative instead of any earlier version included above:
+
+${canonicalCorrected}`
+}

package/src/lib/monaco/bosun-theme.ts

@@ -1,88 +1,5 @@
 import type * as Monaco from 'monaco-editor'
 
-export interface PromptDecorations {
-	update: () => void
-	dispose: () => void
-}
-
-export function createPromptDecorations(
-	monaco: typeof Monaco,
-	editor: Monaco.editor.IStandaloneCodeEditor
-) {
-	const collection = editor.createDecorationsCollection()
-
-	function update() {
-		const model = editor.getModel()
-		if (!model) return
-
-		const decorations: Monaco.editor.IModelDeltaDecoration[] = []
-		const lineCount = model.getLineCount()
-
-		for (let lineNumber = 1; lineNumber <= lineCount; lineNumber++) {
-			const lineText = model.getLineContent(lineNumber)
-
-			//  Headings
-			const match = /^(#+)\s/.exec(lineText)
-			if (match) {
-				const level = match[1].length
-				let cls = 'prompt-heading-3'
-
-				if (level === 1) {
-					cls = 'prompt-heading-1'
-				} else if (level === 2) {
-					cls = 'prompt-heading-2'
-				}
-
-				decorations.push({
-					range: new monaco.Range(lineNumber, 1, lineNumber, lineText.length + 1),
-					options: {
-						isWholeLine: true,
-						inlineClassName: cls
-					}
-				})
-			}
-
-			// Symbols '#' and '*'
-			for (let column = 1; column <= lineText.length; column++) {
-				const ch = lineText[column - 1]
-				if (ch === '#' || ch === '*') {
-					decorations.push({
-						range: new monaco.Range(lineNumber, column, lineNumber, column + 1),
-						options: {
-							inlineClassName: 'prompt-symbol'
-						}
-					})
-				}
-			}
-
-			// Subnumbers
-			const subMatch = lineText.match(/^(\s+)(\d+(?:\.\d+)+\.?)(?=[\s)]|$)/)
-			if (subMatch) {
-				const leading = subMatch[1]
-				const numberText = subMatch[2]
-
-				const startColumn = leading.length + 1
-				const endColumn = startColumn + numberText.length
-
-				decorations.push({
-					range: new monaco.Range(lineNumber, startColumn, lineNumber, endColumn),
-					options: {
-						inlineClassName: 'prompt-subnumber'
-					}
-				})
-			}
-		}
-
-		collection.set(decorations)
-	}
-
-	function dispose() {
-		collection.clear()
-	}
-
-	return { update, dispose }
-}
-
 export const bosunDarkTheme: Monaco.editor.IStandaloneThemeData = {
 	base: 'vs-dark',
 	inherit: true,
@@ -110,6 +27,12 @@ export const bosunDarkTheme: Monaco.editor.IStandaloneThemeData = {
 		'editor.inactiveSelectionBackground': '#4B5563A0',
 		'editor.lineHighlightBackground': '#FFFFFF08',
 		'editorLineNumber.background': '#1D1D1D',
+		'diffEditor.insertedTextBackground': '#00B58A33',
+		'diffEditor.insertedLineBackground': '#00B58A1A',
+		'diffEditor.removedTextBackground': '#FF666633',
+		'diffEditor.removedLineBackground': '#FF66661A',
+		'diffEditor.border': '#373737',
+		'diffEditor.diagonalFill': '#76767633',
 
 		// Nunjucks tag highlight (DocumentHighlightProvider)
 		'editor.wordHighlightBackground': '#ff480159'

package/src/lib/monaco/editor-appearance.spec.ts

@@ -0,0 +1,84 @@
+import type * as Monaco from 'monaco-editor'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import {
+	EDITOR_FONT_FAMILY,
+	EDITOR_FONT_SIZE,
+	createPromptWrapController,
+	getEditorAppearanceOptions
+} from './editor-appearance'
+
+describe('getEditorAppearanceOptions', () => {
+	it('keeps prompt appearance in one preset', () => {
+		expect(getEditorAppearanceOptions('prompt', { bottomPadding: 56 })).toMatchObject({
+			theme: 'bosun-dark',
+			fontSize: EDITOR_FONT_SIZE,
+			fontFamily: EDITOR_FONT_FAMILY,
+			wordWrap: 'bounded',
+			wordWrapColumn: 120,
+			wrappingStrategy: 'advanced',
+			bracketPairColorization: { enabled: true },
+			padding: { top: 32, bottom: 56 }
+		})
+	})
+
+	it('keeps test-history appearance in one preset', () => {
+		expect(getEditorAppearanceOptions('test-history')).toMatchObject({
+			fontSize: EDITOR_FONT_SIZE,
+			fontFamily: EDITOR_FONT_FAMILY,
+			wordWrap: 'bounded',
+			wordWrapColumn: 75,
+			wrappingStrategy: 'advanced',
+			scrollbar: { vertical: 'hidden', horizontal: 'hidden' },
+			padding: { top: 4, bottom: 4 }
+		})
+		expect(getEditorAppearanceOptions('test-history', { bottomPadding: 56 }).padding).toEqual({
+			top: 4,
+			bottom: 56
+		})
+	})
+
+	it('preserves Monaco font defaults for generic diffs', () => {
+		const options = getEditorAppearanceOptions('generic')
+		expect(options).not.toHaveProperty('fontSize')
+		expect(options).not.toHaveProperty('fontFamily')
+	})
+})
+
+describe('createPromptWrapController', () => {
+	afterEach(() => vi.unstubAllGlobals())
+
+	it('updates and disposes responsive wrapping', () => {
+		let frame!: FrameRequestCallback
+		let layoutListener!: () => void
+		const cancelAnimationFrame = vi.fn()
+		vi.stubGlobal('requestAnimationFrame', (callback: FrameRequestCallback) => {
+			frame = callback
+			return 7
+		})
+		vi.stubGlobal('cancelAnimationFrame', cancelAnimationFrame)
+
+		const updateOptions = vi.fn()
+		const disposeLayoutListener = vi.fn()
+		const editor = {
+			getLayoutInfo: () => ({ contentWidth: 724 }),
+			getOption: () => ({ typicalHalfwidthCharacterWidth: 7 }),
+			updateOptions,
+			onDidLayoutChange: (listener: () => void) => {
+				layoutListener = listener
+				return { dispose: disposeLayoutListener }
+			}
+		} as unknown as Monaco.editor.IStandaloneCodeEditor
+		const monaco = {
+			editor: { EditorOption: { fontInfo: 0 } }
+		} as unknown as typeof Monaco
+
+		const controller = createPromptWrapController(editor, monaco)
+		expect(frame).toBeTypeOf('function')
+		frame(0)
+		expect(updateOptions).toHaveBeenCalledWith({ wordWrap: 'bounded', wordWrapColumn: 100 })
+		layoutListener()
+		controller.dispose()
+		expect(disposeLayoutListener).toHaveBeenCalledOnce()
+		expect(cancelAnimationFrame).toHaveBeenCalledWith(7)
+	})
+})