@atom.io/template-react-realtime-text-editor 0.0.11 → 0.0.13

package/tests/collaboration.test.tsx

@@ -1,251 +1,503 @@
-import { act, waitFor } from "@testing-library/react"
-import { useO } from "atom.io/react"
-import type { Socket, UserKey } from "atom.io/realtime"
-import { useMosaic } from "atom.io/realtime-react"
-import { createMosaicServer } from "atom.io/realtime-server"
-import * as RTTest from "atom.io/realtime-testing/react"
-
-import { markdownAtomRegistration } from "../node/mosaic-atom.ts"
+import { waitFor } from "@testing-library/react"
 import {
-	type Markdown,
-	markdownAtom,
-	markdownWordCountSelector,
-	type MarkdownPresence,
-} from "../src/collaboration/mosaic.ts"
+	headless,
+	SeededScenarioRandom,
+	type HeadlessRealtimeTestClient,
+} from "@atom.io/realtime/testing/headless"
+
+import { createMarkdownDocumentService } from "../node/service.ts"
+import {
+	createMarkdownCollaborationClient,
+	type MarkdownCollaborationClient,
+} from "../src/collaboration-client.ts"
 import type { Identity } from "../src/identities.ts"
 import { INITIAL_MARKDOWN } from "../src/initial-markdown.ts"
+import { createMarkdownWorkspaceState } from "../src/workspace-state.ts"
 
-const JANE = { id: `jane`, name: `Jane`, color: `#7057ff` } satisfies Identity
-const DAVE = { id: `dave`, name: `Dave`, color: `#df527c` } satisfies Identity
+const ADA = { color: `#7057ff`, id: `ada`, name: `Ada` } satisfies Identity
+const LIN = { color: `#df527c`, id: `lin`, name: `Lin` } satisfies Identity
+const sessions = { ada: `test:ada`, lin: `test:lin` } as const
 
-function identityFor(userKey: UserKey): Identity {
-	return userKey.includes(`jane`) ? JANE : DAVE
-}
+type RuntimeRegistry = Map<string, MarkdownCollaborationClient>
 
-function testClient(identity: Identity, session: string) {
-	return function TestClient() {
-		const mosaic = useMosaic<InstanceType<typeof Markdown>, MarkdownPresence>(
-			markdownAtom,
-			{ actor: identity.id, session },
-		)
-		const document = useO(markdownAtom)
-		const wordCount = useO(markdownWordCountSelector)
-		const text = document.text
-		const history = document.historyFor(identity.id)
-		return (
-			<main>
-				<output data-testid="text">{text}</output>
-				<output data-testid="word-count">{wordCount}</output>
-				<output data-testid="status">{mosaic.status}</output>
-				<output data-testid="presence">
-					{mosaic.presence
-						.map(({ actor }) => actor)
-						.sort()
-						.join(`,`)}
-				</output>
-				<button
-					type="button"
-					data-testid="append"
-					onClick={() =>
-						mosaic.change({
-							text: `${text}[${identity.name}]`,
-							type: `replace-text`,
-						})
-					}
-				/>
-				<button
-					type="button"
-					data-testid="presence-update"
-					onClick={() => {
-						mosaic.publishPresence({
-							color: identity.color,
-							lastActiveAt: 1,
-							name: identity.name,
-							selection: document.selectionFromOffsets(0, 0),
-						})
-					}}
-				/>
-				<button
-					type="button"
-					data-testid="undo"
-					disabled={history.undo.length === 0}
-					onClick={() => mosaic.change({ type: `undo` })}
-				/>
-				<button
-					type="button"
-					data-testid="redo"
-					disabled={history.redo.length === 0}
-					onClick={() => mosaic.change({ type: `redo` })}
-				/>
-			</main>
-		)
-	}
-}
+const INITIAL = `# Bounded notes\n\n${Array.from(
+	{ length: 10 },
+	(_, index) =>
+		`Paragraph ${index} has enough text to exercise partial residency.`,
+).join(`\n\n`)}\n`
 
-function scenario() {
-	const collaboration = createMosaicServer({
-		registrations: [markdownAtomRegistration],
+async function scenario(
+	options: {
+		readonly initialText?: string
+		readonly presenceRenewalMs?: number
+		readonly presenceTtlMs?: number
+	} = {},
+) {
+	const service = await createMarkdownDocumentService({
+		initialText: options.initialText ?? INITIAL,
+		presenceTtlMs: options.presenceTtlMs,
 	})
-	const room = RTTest.multiClient({
-		scenarioId: `mosaic-markdown`,
-		server: ({ sessionId, socket, userKey }) => {
-			const dispose = collaboration.connect({
-				actor: identityFor(userKey).id,
-				session: sessionId,
-				socket: socket as unknown as Socket,
-			})
+	const runtimes: RuntimeRegistry = new Map()
+	const room = headless({
+		scenarioId: `mosaic-markdown-domain`,
+		server: (tools) => {
+			const binding = tools.work.track(
+				service.bindSocket({
+					actor: tools.userKey.replace(/^user::/u, ``),
+					session: tools.sessionId,
+					socket: tools.socket,
+				}),
+				`bind Markdown Domain socket`,
+			)
 			return () => {
-				void dispose()
+				void binding.then((cleanup) => cleanup())
 			}
 		},
-		clients: {
-			jane: testClient(JANE, `test:jane`),
-			dave: testClient(DAVE, `test:dave`),
-		},
 	})
 	return {
-		...room,
-		teardown: async (): Promise<void> => {
+		room,
+		runtimes,
+		service,
+		presenceRenewalMs: options.presenceRenewalMs,
+		async teardown() {
+			for (const runtime of runtimes.values()) runtime[Symbol.dispose]()
+			runtimes.clear()
 			await room.teardown()
-			await collaboration.dispose()
+			service[Symbol.dispose]()
 		},
 	}
 }
 
-const initJane = (room: ReturnType<typeof scenario>) =>
-	room.clients.jane.init({
-		sessionId: `test:jane`,
-		userKey: `user::jane`,
-	})
+async function initialize(room: Awaited<ReturnType<typeof scenario>>): Promise<{
+	ada: HeadlessRealtimeTestClient
+	lin: HeadlessRealtimeTestClient
+}> {
+	const harness = {
+		ada: room.room.createClient({
+			name: `ada`,
+			sessionId: sessions.ada,
+			userKey: `user::ada`,
+		}),
+		lin: room.room.createClient({
+			name: `lin`,
+			sessionId: sessions.lin,
+			userKey: `user::lin`,
+		}),
+	}
+	const [ada, lin] = await Promise.all([
+		createMarkdownCollaborationClient({
+			identity: ADA,
+			presenceRenewalMs: room.presenceRenewalMs,
+			sessionId: sessions.ada,
+			silo: harness.ada.silo,
+			socket: harness.ada.socket,
+		}),
+		createMarkdownCollaborationClient({
+			identity: LIN,
+			presenceRenewalMs: room.presenceRenewalMs,
+			sessionId: sessions.lin,
+			silo: harness.lin.silo,
+			socket: harness.lin.socket,
+		}),
+	])
+	room.runtimes.set(sessions.ada, ada)
+	room.runtimes.set(sessions.lin, lin)
+	return harness
+}
 
-const initDave = (room: ReturnType<typeof scenario>) =>
-	room.clients.dave.init({
-		sessionId: `test:dave`,
-		userKey: `user::dave`,
-	})
+async function live(room: Awaited<ReturnType<typeof scenario>>) {
+	await waitFor(
+		() => {
+			expect(room.runtimes.get(sessions.ada)?.status().connection).toBe(`live`)
+			expect(room.runtimes.get(sessions.lin)?.status().connection).toBe(`live`)
+		},
+		{ timeout: 5_000 },
+	)
+	return {
+		ada: room.runtimes.get(sessions.ada)!,
+		lin: room.runtimes.get(sessions.lin)!,
+	}
+}
 
-async function expectText(
-	client: RTTest.RealtimeTestClient,
-	text: string,
-): Promise<void> {
-	await waitFor(() => {
-		expect(client.renderResult.getByTestId(`text`).textContent).toBe(text)
+describe(`incremental realtime Markdown Domain`, () => {
+	test.each([0x51_0c_10, 0xc0_ff_ee, 0x12_34_56])(
+		`seed %i: single-writer replacements converge to a plain-text oracle`,
+		async (seed) => {
+			const setup = await scenario({ initialText: INITIAL_MARKDOWN })
+			try {
+				await initialize(setup)
+				const clients = await live(setup)
+				const random = new SeededScenarioRandom(seed)
+				const alphabet = [`x`, `y`, ` `, `!`, `😀`] as const
+				const segmenter = new Intl.Segmenter(undefined, {
+					granularity: `grapheme`,
+				})
+				let oracle = INITIAL_MARKDOWN
+
+				// Exercise the real client/server protocol without keyboard travel or
+				// wall-clock sleeps. Native editing and painting stay in Playwright.
+				for (let step = 0; step < 100; step++) {
+					const boundaries = [0]
+					for (const { index, segment } of segmenter.segment(oracle)) {
+						boundaries.push(index + segment.length)
+					}
+					const startIndex = random.integer(boundaries.length)
+					const removable = Math.min(3, boundaries.length - 1 - startIndex)
+					const removed = removable === 0 ? 0 : random.integer(removable + 1)
+					const start = boundaries[startIndex]
+					const end = boundaries[startIndex + removed]
+					let inserted: string = random.pick(alphabet)
+					// Submit actual edits; the command protocol rejects no-op replacements.
+					if (oracle.slice(start, end) === inserted) inserted += `x`
+					const writer = clients.ada
+					const anchor = await writer.projection.positionAtOffset(start)
+					const head = await writer.projection.positionAtOffset(end)
+					const context = `seed ${seed.toString(16)} step ${step}: replace ${start}..${end} with ${JSON.stringify(inserted)}`
+					await writer.replace({ selection: { anchor, head }, text: inserted })
+					oracle = `${oracle.slice(0, start)}${inserted}${oracle.slice(end)}`
+					await setup.room.waitForIdle()
+					expect(setup.service.materialize(), context).toBe(oracle)
+					for (const client of [clients.ada, clients.lin]) {
+						expect(await client.projection.materialize(), context).toBe(oracle)
+					}
+				}
+			} finally {
+				await setup.teardown()
+			}
+		},
+	)
+
+	test(`the store-owned workspace hydrates its initial viewport`, async () => {
+		const setup = await scenario()
+		try {
+			const harness = await initialize(setup)
+			const clients = await live(setup)
+			const observeErrors: unknown[] = []
+			const originalObserveRange = clients.ada.projection.observeRange
+			const observeRange = vi
+				.spyOn(clients.ada.projection, `observeRange`)
+				.mockImplementation(async (...parameters) => {
+					try {
+						return await originalObserveRange(...parameters)
+					} catch (error) {
+						observeErrors.push(error)
+						throw error
+					}
+				})
+			const workspace = createMarkdownWorkspaceState({
+				client: clients.ada,
+				silo: harness.ada.silo,
+			})
+			try {
+				await waitFor(() => {
+					expect(harness.ada.silo.getState(workspace.totalLength)).toBe(
+						INITIAL.length,
+					)
+				})
+				expect(observeRange.mock.calls.map(([range]) => range)).toEqual([
+					{ end: INITIAL.length, kind: `utf16-range`, start: 0 },
+				])
+				await waitFor(() => {
+					expect(observeErrors).toEqual([])
+					expect(observeRange).toHaveBeenCalled()
+					expect(harness.ada.silo.getState(workspace.view)).toMatchObject({
+						projection: { text: INITIAL },
+						status: `ready`,
+					})
+				})
+			} finally {
+				workspace[Symbol.dispose]()
+			}
+		} finally {
+			await setup.teardown()
+		}
 	})
-}
 
-async function expectStatus(
-	client: RTTest.RealtimeTestClient,
-	status: string,
-): Promise<void> {
-	await waitFor(() => {
-		expect(client.renderResult.getByTestId(`status`).textContent).toBe(status)
+	test(`rejects invalid presence renewal intervals before allocating a Domain`, async () => {
+		await expect(
+			createMarkdownCollaborationClient({
+				identity: ADA,
+				presenceRenewalMs: 0,
+				sessionId: `invalid-presence-renewal`,
+				silo: {} as never,
+				socket: {} as never,
+			}),
+		).rejects.toThrow(`positive integer`)
 	})
-}
 
-describe(`realtime collaborative Markdown`, () => {
-	test(`offline concurrent edits rebase and converge for both clients`, async () => {
-		const room = scenario()
-		const jane = initJane(room)
-		const dave = initDave(room)
-		await expectText(jane, INITIAL_MARKDOWN)
-		await expectText(dave, INITIAL_MARKDOWN)
-
-		act(() => {
-			jane.socket.disconnect()
-			dave.socket.disconnect()
-		})
-		await expectStatus(jane, `offline`)
-		await expectStatus(dave, `offline`)
-		act(() => {
-			jane.renderResult.getByTestId(`append`).click()
-			dave.renderResult.getByTestId(`append`).click()
-		})
+	test(`hydrates viewport first, converges contention/offline work, and keeps selective history foreign-safe`, async () => {
+		const setup = await scenario()
+		try {
+			const harness = await initialize(setup)
+			const clients = await live(setup)
+			const length = await clients.ada.projection.readLength()
+			const [first, last] = await Promise.all([
+				clients.ada.projection.acquireRange({
+					end: 512,
+					kind: `utf16-range`,
+					start: 0,
+				}),
+				clients.lin.projection.acquireRange({
+					end: length,
+					kind: `utf16-range`,
+					start: length - 512,
+				}),
+			])
+			expect(first.read().text).toBe(INITIAL.slice(0, 512))
+			expect(last.read().text).toBe(INITIAL.slice(-512))
+			expect(setup.service.instrumentation.materializations).toBe(0)
+			expect(clients.ada.residency.state.residentMemberCount).toBeLessThan(12)
+			expect(clients.lin.residency.state.residentMemberCount).toBeLessThan(12)
+			expect(
+				await clients.ada.residency.resident(
+					clients.ada.domain.address(`source`),
+				),
+			).toBeNull()
 
-		act(() => {
-			jane.socket.connect()
-			dave.socket.connect()
-		})
-		await waitFor(() => {
-			const janeText = jane.renderResult.getByTestId(`text`).textContent ?? ``
-			const daveText = dave.renderResult.getByTestId(`text`).textContent ?? ``
-			expect(janeText).toBe(daveText)
-			expect(janeText).toContain(`[Jane]`)
-			expect(janeText).toContain(`[Dave]`)
-			expect(jane.renderResult.getByTestId(`word-count`).textContent).toBe(
-				dave.renderResult.getByTestId(`word-count`).textContent,
-			)
-		})
-		await room.teardown()
-	})
+			const shrinkStart = await clients.ada.projection.positionAtOffset(2)
+			const shrinkEnd = await clients.ada.projection.positionAtOffset(28)
+			await clients.ada.replace({
+				selection: { anchor: shrinkStart, head: shrinkEnd },
+				text: `[Ada-shrinks]`,
+			})
+			expect(first.read().text).toContain(`[Ada-shrinks]`)
+			expect(first.read().text).not.toContain(`Field notes for the launch`)
 
-	test(`one identity's undo preserves a later foreign edit`, async () => {
-		const room = scenario()
-		const jane = initJane(room)
-		const dave = initDave(room)
-		await expectStatus(jane, `live`)
-		await expectStatus(dave, `live`)
+			const sameBoundary = await clients.ada.projection.positionAtOffset(16)
+			await Promise.all([
+				clients.ada.replace({
+					selection: { anchor: sameBoundary, head: sameBoundary },
+					text: `[Ada]`,
+				}),
+				clients.lin.replace({
+					selection: { anchor: sameBoundary, head: sameBoundary },
+					text: `[Lin]`,
+				}),
+			])
+			const contended = await clients.ada.projection.materialize()
+			expect(contended).toContain(`[Ada]`)
+			expect(contended).toContain(`[Lin]`)
+			await waitFor(() => {
+				expect(first.read().text).toContain(`[Ada]`)
+				expect(first.read().text).toContain(`[Lin]`)
+			})
+			await waitFor(async () => {
+				expect(await clients.ada.projection.readLength()).toBe(contended.length)
+			})
 
-		act(() => {
-			jane.renderResult.getByTestId(`append`).click()
-		})
-		await waitFor(() => {
-			expect(dave.renderResult.getByTestId(`text`).textContent).toContain(
-				`[Jane]`,
+			const adaEnd = await clients.ada.projection.positionAtOffset(
+				contended.length,
 			)
-		})
-		act(() => {
-			dave.renderResult.getByTestId(`append`).click()
-		})
-		await waitFor(() => {
-			expect(jane.renderResult.getByTestId(`text`).textContent).toContain(
-				`[Dave]`,
+			await clients.ada.replace({
+				selection: { anchor: adaEnd, head: adaEnd },
+				text: `[Ada-history]`,
+			})
+			const afterAda = await clients.lin.projection.materialize()
+			await waitFor(async () => {
+				expect(await clients.lin.projection.readLength()).toBe(afterAda.length)
+			})
+			const linEnd = await clients.lin.projection.positionAtOffset(
+				afterAda.length,
 			)
-		})
+			await clients.lin.replace({
+				selection: { anchor: linEnd, head: linEnd },
+				text: `[Lin-foreign]`,
+			})
+			expect(await clients.ada.undo()).toBe(true)
+			const undone = await clients.lin.projection.materialize()
+			expect(undone).not.toContain(`[Ada-history]`)
+			expect(undone).toContain(`[Lin-foreign]`)
+			expect(await clients.ada.redo()).toBe(true)
+			await last.release()
 
-		act(() => {
-			jane.renderResult.getByTestId(`undo`).click()
-		})
-		await waitFor(() => {
-			const text = jane.renderResult.getByTestId(`text`).textContent ?? ``
-			expect(text).not.toContain(`[Jane]`)
-			expect(text).toContain(`[Dave]`)
-			expect(dave.renderResult.getByTestId(`text`).textContent).toBe(text)
-		})
+			harness.ada.socket.disconnect()
+			const offlineAnchor = await clients.ada.projection.positionAtOffset(4)
+			const pending = clients.ada.replace({
+				selection: { anchor: offlineAnchor, head: offlineAnchor },
+				text: `[offline]`,
+			})
+			const foreignAnchor = await clients.lin.projection.positionAtOffset(4)
+			await clients.lin.replace({
+				selection: { anchor: foreignAnchor, head: foreignAnchor },
+				text: `[online]`,
+			})
+			harness.ada.socket.connect()
+			await waitFor(
+				() => {
+					expect(clients.ada.status().connection).toBe(`live`)
+				},
+				{
+					timeout: 5_000,
+				},
+			)
+			await pending
+			await setup.room.waitForIdle()
+			await first.release()
+			const reconnected = await clients.lin.projection.materialize()
+			expect(reconnected).toContain(`[offline]`)
+			expect(reconnected).toContain(`[online]`)
+			expect(setup.service.instrumentation.lastBatchOperations).toBeLessThan(16)
 
-		act(() => {
-			jane.renderResult.getByTestId(`redo`).click()
-		})
-		await waitFor(() => {
-			const text = jane.renderResult.getByTestId(`text`).textContent ?? ``
-			expect(text).toContain(`[Jane]`)
-			expect(text).toContain(`[Dave]`)
-			expect(dave.renderResult.getByTestId(`text`).textContent).toBe(text)
-		})
-		await room.teardown()
+			const resetStart = await clients.ada.projection.positionAtOffset(0)
+			const resetEnd = await clients.ada.projection.positionAtOffset(
+				reconnected.length,
+			)
+			await clients.ada.replace({
+				selection: { anchor: resetStart, head: resetEnd },
+				text: ``,
+			})
+			await waitFor(async () => {
+				expect(await clients.lin.projection.readLength()).toBe(0)
+			})
+			expect(await clients.lin.projection.materialize()).toBe(``)
+			await expect(setup.service.positionAtOffset(1)).rejects.toThrow(
+				`outside the Mosaic text index`,
+			)
+			const empty = await clients.ada.projection.positionAtOffset(0)
+			expect(empty).toEqual({ affinity: `left`, offset: 0, runId: null })
+			await clients.ada.replace({
+				selection: { anchor: empty, head: empty },
+				text: `[reset-all]`,
+			})
+			await waitFor(async () => {
+				expect(await clients.lin.projection.materialize()).toBe(`[reset-all]`)
+			})
+		} finally {
+			await setup.teardown()
+		}
 	})
 
-	test(`presence is model-aware and removed on disconnect`, async () => {
-		const room = scenario()
-		const jane = initJane(room)
-		const dave = initDave(room)
-		await expectStatus(jane, `live`)
-		await expectStatus(dave, `live`)
-		act(() => {
-			jane.renderResult.getByTestId(`presence-update`).click()
-			dave.renderResult.getByTestId(`presence-update`).click()
+	test(`presence is logical/ephemeral and import is one authorized resnapshot cut`, async () => {
+		const setup = await scenario({
+			presenceRenewalMs: 20,
+			presenceTtlMs: 80,
 		})
-		await waitFor(() => {
-			expect(jane.renderResult.getByTestId(`presence`).textContent).toBe(
-				`dave,jane`,
+		try {
+			const harness = await initialize(setup)
+			const clients = await live(setup)
+			const caretOffset = INITIAL.lastIndexOf(`partial residency`)
+			const caret = await clients.ada.projection.positionAtOffset(caretOffset)
+			await clients.ada.publishPresence({
+				color: ADA.color,
+				name: ADA.name,
+				selection: { anchor: caret, head: caret },
+				viewport: null,
+			})
+			await setup.room.waitForIdle()
+			await clients.lin.presence.flush()
+			expect(
+				clients.lin.presence.state.presence.some(
+					(envelope) => envelope.kind === `update` && envelope.actor === ADA.id,
+				),
+			).toBe(true)
+			const documentStart = await clients.lin.projection.positionAtOffset(0)
+			const prefix = `[Lin-prefix]`
+			await clients.lin.replace({
+				selection: { anchor: documentStart, head: documentStart },
+				text: prefix,
+			})
+			await waitFor(async () => {
+				expect(await clients.lin.projection.resolvePosition(caret)).toBe(
+					caretOffset + prefix.length,
+				)
+			})
+			await new Promise((resolve) => setTimeout(resolve, 200))
+			await setup.room.waitForIdle()
+			await clients.lin.presence.flush()
+			expect(
+				clients.lin.presence.state.presence.some(
+					(envelope) => envelope.kind === `update` && envelope.actor === ADA.id,
+				),
+			).toBe(true)
+			harness.ada.socket.disconnect()
+			await waitFor(() => {
+				expect(
+					clients.lin.presence.state.presence.some(
+						(envelope) =>
+							envelope.kind === `update` && envelope.actor === ADA.id,
+					),
+				).toBe(false)
+			})
+
+			const importedRange = await clients.lin.projection.acquireRange({
+				end: 16,
+				kind: `utf16-range`,
+				start: 0,
+			})
+			const revision = setup.service.revision
+			await expect(
+				setup.service.command({
+					actor: LIN.id,
+					command: {
+						gestureId: `unauthorized-import`,
+						sequence: 1,
+						text: `denied`,
+						type: `import`,
+					},
+					session: `lin-admin`,
+				}),
+			).rejects.toThrow(`authorized`)
+			await setup.service.command({
+				actor: ADA.id,
+				command: {
+					gestureId: `authorized-import`,
+					sequence: 1,
+					text: `# Imported once\n\n${`x`.repeat(100_000)}`,
+					type: `import`,
+				},
+				session: `ada-admin`,
+			})
+			expect(setup.service.revision).toBe(revision + 1)
+			expect(setup.service.materialize().startsWith(`# Imported once`)).toBe(
+				true,
 			)
-		})
+			expect(setup.service.instrumentation.lastBatchOperations).toBeGreaterThan(
+				4,
+			)
+			await waitFor(() => {
+				expect(importedRange.read().text.startsWith(`# Imported once`)).toBe(
+					true,
+				)
+			})
+			await setup.service.command({
+				actor: ADA.id,
+				command: {
+					gestureId: `authorized-merge`,
+					sequence: 2,
+					text: `# Compacted again\n`,
+					type: `import`,
+				},
+				session: `ada-admin`,
+			})
+			expect(setup.service.revision).toBe(revision + 2)
+			await waitFor(() => {
+				expect(importedRange.read().text).toBe(`# Compacted agai`)
+			})
+			await importedRange.release()
+		} finally {
+			await setup.teardown()
+		}
+	})
 
-		act(() => {
-			dave.socket.disconnect()
-		})
-		await waitFor(() => {
-			expect(jane.renderResult.getByTestId(`presence`).textContent).toBe(`jane`)
-		})
-		await room.teardown()
+	test(`settles an offline command when its collaboration client is disposed`, async () => {
+		const setup = await scenario()
+		try {
+			const harness = await initialize(setup)
+			const clients = await live(setup)
+			const caret = await clients.ada.projection.positionAtOffset(4)
+			harness.ada.socket.disconnect()
+			await waitFor(() => {
+				expect(clients.ada.status().connection).toBe(`offline`)
+			})
+			const pending = clients.ada.replace({
+				selection: { anchor: caret, head: caret },
+				text: `[abandoned]`,
+			})
+			await Promise.resolve()
+			clients.ada[Symbol.dispose]()
+			await expect(pending).rejects.toThrow(`disposed`)
+		} finally {
+			await setup.teardown()
+		}
 	})
 })