@tldraw/sync-core 4.3.0-canary.c7096a59bf3b → 4.3.0-canary.d039f3a1ab8f

package/src/test/TestServer.ts

@@ -1,11 +1,22 @@
 import { StoreSchema, UnknownRecord } from '@tldraw/store'
+import { InMemorySyncStorage } from '../lib/InMemorySyncStorage'
 import { RoomSnapshot, TLSyncRoom } from '../lib/TLSyncRoom'
 import { TestSocketPair } from './TestSocketPair'
 
 export class TestServer<R extends UnknownRecord, P = unknown> {
 	room: TLSyncRoom<R, undefined>
+	storage: InMemorySyncStorage<R>
 	constructor(schema: StoreSchema<R, P>, snapshot?: RoomSnapshot) {
-		this.room = new TLSyncRoom<R, undefined>({ schema, snapshot })
+		// Use provided snapshot or create an empty one with the current schema
+		this.storage = new InMemorySyncStorage<R>({
+			snapshot: snapshot ?? {
+				documents: [],
+				clock: 0,
+				documentClock: 0,
+				schema: schema.serialize(),
+			},
+		})
+		this.room = new TLSyncRoom<R, undefined>({ schema, storage: this.storage })
 	}
 
 	connect(socketPair: TestSocketPair<R>): void {

package/src/test/customMessages.test.ts

@@ -12,7 +12,7 @@ const schema = StoreSchema.create<Presence>({ presence: presenceType })
 
 describe('custom messages', () => {
 	it('sends a message to a client', async () => {
-		const store = new Store({ schema, props: {} })
+		const store = new Store<any, any>({ schema, props: {} })
 
 		const sessionId = 'test-session-1'
 		const server = new TestServer(schema)

package/src/test/presenceMode.test.ts

@@ -97,21 +97,21 @@ test('presence is pushed on change when mode is full', () => {
 	const session = t.server.room.sessions.values().next().value
 	expect(session).toBeDefined()
 	expect(session?.presenceId).toBeDefined()
-	expect(t.server.room.documents.get(session!.presenceId!)?.state).toMatchObject({
+	expect(t.server.room.presenceStore.get(session!.presenceId!)).toMatchObject({
 		name: 'bob',
 		age: 10,
 	})
 
 	presenceSignal.set(Presence.create({ name: 'bob', age: 11 }))
 	t.flush()
-	expect(t.server.room.documents.get(session!.presenceId!)?.state).toMatchObject({
+	expect(t.server.room.presenceStore.get(session!.presenceId!)).toMatchObject({
 		name: 'bob',
 		age: 11,
 	})
 
 	presenceSignal.set(Presence.create({ name: 'bob', age: 12 }))
 	t.flush()
-	expect(t.server.room.documents.get(session!.presenceId!)?.state).toMatchObject({
+	expect(t.server.room.presenceStore.get(session!.presenceId!)).toMatchObject({
 		name: 'bob',
 		age: 12,
 	})
@@ -128,21 +128,21 @@ test('presence is only pushed once on connect when mode is solo', () => {
 	const session = t.server.room.sessions.values().next().value
 	expect(session).toBeDefined()
 	expect(session?.presenceId).toBeDefined()
-	expect(t.server.room.documents.get(session!.presenceId!)?.state).toMatchObject({
+	expect(t.server.room.presenceStore.get(session!.presenceId!)).toMatchObject({
 		name: 'bob',
 		age: 10,
 	})
 
 	presenceSignal.set(Presence.create({ name: 'bob', age: 11 }))
 	t.flush()
-	expect(t.server.room.documents.get(session!.presenceId!)?.state).not.toMatchObject({
+	expect(t.server.room.presenceStore.get(session!.presenceId!)).not.toMatchObject({
 		name: 'bob',
 		age: 11,
 	})
 
 	presenceSignal.set(Presence.create({ name: 'bob', age: 12 }))
 	t.flush()
-	expect(t.server.room.documents.get(session!.presenceId!)?.state).not.toMatchObject({
+	expect(t.server.room.presenceStore.get(session!.presenceId!)).not.toMatchObject({
 		name: 'bob',
 		age: 12,
 	})

package/src/test/upgradeDowngrade.test.ts

@@ -228,11 +228,11 @@ test('the server can handle receiving v1 stuff from the client', () => {
 	t.oldClient.store.put([user])
 	t.flush()
 
-	expect(t.server.room.documents.get(user.id)?.state).toMatchObject({
+	expect(t.server.storage.documents.get(user.id)?.state).toMatchObject({
 		name: 'bob',
 		birthdate: null,
 	})
-	expect(t.server.room.documents.get(user.id)?.state).not.toMatchObject({
+	expect(t.server.storage.documents.get(user.id)?.state).not.toMatchObject({
 		name: 'bob',
 		age: 10,
 	})
@@ -254,7 +254,7 @@ test('the server can send v2 stuff to the v1 client', () => {
 	t.newClient.store.put([user])
 	t.flush()
 
-	expect(t.server.room.documents.get(user.id)?.state).toMatchObject({
+	expect(t.server.storage.documents.get(user.id)?.state).toMatchObject({
 		name: 'bob',
 		birthdate: '2022-01-09',
 	})
@@ -287,14 +287,14 @@ test('the server will run schema migrations on a snapshot', () => {
 		schemaV3
 	)
 
-	expect(t.server.room.documents.get(bob.id)?.state).toMatchObject({
+	expect(t.server.storage.documents.get(bob.id)?.state).toMatchObject({
 		name: 'bob',
 		birthdate: null,
 	})
-	expect(t.server.room.documents.get(joe.id)).toBeUndefined()
+	expect(t.server.storage.documents.get(joe.id)).toBeUndefined()
 
 	// there should be someone named steve
-	const snapshot = t.server.room.getSnapshot()
+	const snapshot = t.server.storage.getSnapshot()
 	expect(snapshot.documents.find((u: any) => u.state.name === 'steve')).toBeDefined()
 })
 
@@ -309,7 +309,7 @@ test('clients will receive updates from a snapshot migration upon connection', (
 	t.newClient.store.put([bob, joe])
 	t.flush()
 
-	const snapshot = t.server.room.getSnapshot()
+	const snapshot = t.server.storage.getSnapshot()
 
 	t.oldSocketPair.disconnect()
 	t.newSocketPair.disconnect()
@@ -333,7 +333,7 @@ test('clients will receive updates from a snapshot migration upon connection', (
 	newServer.room.handleMessage(id, {
 		type: 'connect',
 		connectRequestId: 'test',
-		lastServerClock: snapshot.clock,
+		lastServerClock: snapshot.documentClock ?? snapshot.clock ?? 0,
 		protocolVersion: getTlsyncProtocolVersion(),
 		schema: schemaV3.serialize(),
 	})
@@ -670,6 +670,280 @@ describe('when the client is too old', () => {
 	})
 })
 
+describe('migration failure during push (TLSyncError handling)', () => {
+	// Create a schema where migrations will fail during push
+	const UserVersionsWithFailure = createMigrationIds('com.tldraw.user.failure', {
+		AddNickname: 1,
+	} as const)
+
+	interface UserWithNickname extends BaseRecord<'user_fail', RecordId<UserWithNickname>> {
+		name: string
+		nickname: string
+	}
+
+	const UserWithNicknameType = createRecordType<UserWithNickname>('user_fail', {
+		scope: 'document',
+		validator: { validate: (value) => value as UserWithNickname },
+	})
+
+	interface UserWithoutNickname extends BaseRecord<'user_fail', RecordId<UserWithoutNickname>> {
+		name: string
+	}
+
+	const UserWithoutNicknameType = createRecordType<UserWithoutNickname>('user_fail', {
+		scope: 'document',
+		validator: { validate: (value) => value as UserWithoutNickname },
+	})
+
+	// Server schema with migration that throws on specific conditions
+	// - up() throws when name === 'FAIL_UP_MIGRATION'
+	// - down() throws when nickname === 'FAIL_DOWN_MIGRATION'
+	const serverSchemaWithThrowingMigration = StoreSchema.create<UserWithNickname>(
+		{ user_fail: UserWithNicknameType },
+		{
+			migrations: [
+				createRecordMigrationSequence({
+					sequenceId: 'com.tldraw.user.failure',
+					recordType: 'user_fail',
+					sequence: [
+						{
+							id: UserVersionsWithFailure.AddNickname,
+							up(record: any) {
+								// Simulate UP migration failure for specific data
+								if (record.name === 'FAIL_UP_MIGRATION') {
+									throw new Error('UP migration intentionally failed for testing')
+								}
+								return {
+									...record,
+									nickname: record.name.toUpperCase(),
+								}
+							},
+							down(record: any) {
+								// Simulate DOWN migration failure for specific data
+								if (record.nickname === 'FAIL_DOWN_MIGRATION') {
+									throw new Error('DOWN migration intentionally failed for testing')
+								}
+								const { nickname: _, ...rest } = record
+								return rest
+							},
+						},
+					],
+				}),
+			],
+		}
+	)
+
+	// Client schema (old version without nickname)
+	const clientSchemaWithoutNickname = StoreSchema.create<UserWithoutNickname>(
+		{ user_fail: UserWithoutNicknameType },
+		{
+			migrations: [
+				createMigrationSequence({
+					sequenceId: 'com.tldraw.user.failure',
+					sequence: [],
+					retroactive: true,
+				}),
+			],
+		}
+	)
+
+	it('rejects session when addDocument UP migration throws during PUT', () => {
+		const server = new TestServer(serverSchemaWithThrowingMigration)
+
+		const sessionId = 'failing-migration-session'
+		const socket = mockSocket<UserWithNickname>()
+
+		server.room.handleNewSession({
+			sessionId,
+			socket: socket as any,
+			meta: undefined,
+			isReadonly: false,
+		})
+
+		// Connect with old schema - should succeed since migration has down function
+		server.room.handleMessage(sessionId, {
+			type: 'connect',
+			connectRequestId: 'test',
+			lastServerClock: 0,
+			protocolVersion: getTlsyncProtocolVersion(),
+			schema: clientSchemaWithoutNickname.serialize(),
+		})
+
+		expect(server.room.sessions.get(sessionId)?.state).toBe('connected')
+		;(socket.sendMessage as Mock).mockClear()
+
+		// Push a record that will cause the UP migration to throw
+		const failingRecord = UserWithoutNicknameType.create({
+			id: UserWithoutNicknameType.createId('fail'),
+			name: 'FAIL_UP_MIGRATION', // This name triggers the UP throw
+		})
+
+		server.room.handleMessage(sessionId, {
+			type: 'push',
+			clientClock: 1,
+			diff: {
+				[failingRecord.id]: [RecordOpType.Put, failingRecord as any],
+			},
+		})
+
+		// Session should be rejected due to migration failure (TLSyncError)
+		expect(socket.close).toHaveBeenCalledWith(4099, TLSyncErrorCloseEventReason.CLIENT_TOO_OLD)
+	})
+
+	it('successfully migrates records when migration does not throw', () => {
+		const server = new TestServer(serverSchemaWithThrowingMigration)
+
+		const sessionId = 'successful-migration-session'
+		const socket = mockSocket<UserWithNickname>()
+
+		server.room.handleNewSession({
+			sessionId,
+			socket: socket as any,
+			meta: undefined,
+			isReadonly: false,
+		})
+
+		// Connect with old schema
+		server.room.handleMessage(sessionId, {
+			type: 'connect',
+			connectRequestId: 'test',
+			lastServerClock: 0,
+			protocolVersion: getTlsyncProtocolVersion(),
+			schema: clientSchemaWithoutNickname.serialize(),
+		})
+
+		expect(server.room.sessions.get(sessionId)?.state).toBe('connected')
+		;(socket.sendMessage as Mock).mockClear()
+
+		// Push a record that will NOT cause the migration to throw
+		const validRecord = UserWithoutNicknameType.create({
+			id: UserWithoutNicknameType.createId('valid'),
+			name: 'ValidName', // This name does not trigger the throw
+		})
+
+		server.room.handleMessage(sessionId, {
+			type: 'push',
+			clientClock: 1,
+			diff: {
+				[validRecord.id]: [RecordOpType.Put, validRecord as any],
+			},
+		})
+
+		// Session should still be connected
+		expect(server.room.sessions.get(sessionId)?.state).toBe('connected')
+
+		// Record should be migrated and stored
+		const storedRecord = server.storage.documents.get(validRecord.id)?.state as UserWithNickname
+		expect(storedRecord).toBeDefined()
+		expect(storedRecord.nickname).toBe('VALIDNAME') // Uppercase from migration
+	})
+
+	it('rejects session when patchDocument DOWN migration throws', () => {
+		// Create a server with a document that has a nickname that will fail DOWN migration
+		const existingUser = UserWithNicknameType.create({
+			id: UserWithNicknameType.createId('existing_down_fail'),
+			name: 'ExistingUser',
+			nickname: 'FAIL_DOWN_MIGRATION', // This nickname triggers the DOWN throw
+		})
+
+		const server = new TestServer(serverSchemaWithThrowingMigration, {
+			clock: 10,
+			documents: [{ state: existingUser, lastChangedClock: 10 }],
+			schema: serverSchemaWithThrowingMigration.serialize(),
+			tombstones: {},
+		})
+
+		const sessionId = 'patch-down-migration-session'
+		const socket = mockSocket<UserWithNickname>()
+
+		server.room.handleNewSession({
+			sessionId,
+			socket: socket as any,
+			meta: undefined,
+			isReadonly: false,
+		})
+
+		// Connect with old schema
+		server.room.handleMessage(sessionId, {
+			type: 'connect',
+			connectRequestId: 'test',
+			lastServerClock: 10,
+			protocolVersion: getTlsyncProtocolVersion(),
+			schema: clientSchemaWithoutNickname.serialize(),
+		})
+
+		expect(server.room.sessions.get(sessionId)?.state).toBe('connected')
+		;(socket.sendMessage as Mock).mockClear()
+
+		// Patch the existing record - the DOWN migration will fail because nickname is 'FAIL_DOWN_MIGRATION'
+		// This tests line 951 in TLSyncRoom.ts
+		server.room.handleMessage(sessionId, {
+			type: 'push',
+			clientClock: 1,
+			diff: {
+				[existingUser.id]: [RecordOpType.Patch, { name: [ValueOpType.Put, 'NewName'] }],
+			},
+		})
+
+		// Session should be rejected due to DOWN migration failure
+		expect(socket.close).toHaveBeenCalledWith(4099, TLSyncErrorCloseEventReason.CLIENT_TOO_OLD)
+	})
+
+	it('rejects session when patchDocument UP migration throws (after successful DOWN migration)', () => {
+		// Create a server with a document that will pass DOWN migration but fail UP migration
+		const existingUser = UserWithNicknameType.create({
+			id: UserWithNicknameType.createId('existing_up_fail'),
+			name: 'ExistingUser',
+			nickname: 'EXISTINGUSER', // Normal nickname, DOWN migration will succeed
+		})
+
+		const server = new TestServer(serverSchemaWithThrowingMigration, {
+			clock: 10,
+			documents: [{ state: existingUser, lastChangedClock: 10 }],
+			schema: serverSchemaWithThrowingMigration.serialize(),
+			tombstones: {},
+		})
+
+		const sessionId = 'patch-up-migration-session'
+		const socket = mockSocket<UserWithNickname>()
+
+		server.room.handleNewSession({
+			sessionId,
+			socket: socket as any,
+			meta: undefined,
+			isReadonly: false,
+		})
+
+		// Connect with old schema
+		server.room.handleMessage(sessionId, {
+			type: 'connect',
+			connectRequestId: 'test',
+			lastServerClock: 10,
+			protocolVersion: getTlsyncProtocolVersion(),
+			schema: clientSchemaWithoutNickname.serialize(),
+		})
+
+		expect(server.room.sessions.get(sessionId)?.state).toBe('connected')
+		;(socket.sendMessage as Mock).mockClear()
+
+		// Patch the existing record - changes the name to 'FAIL_UP_MIGRATION'
+		// 1. DOWN migration: {name: 'ExistingUser', nickname: 'EXISTINGUSER'} -> {name: 'ExistingUser'} (succeeds)
+		// 2. Patch applied: {name: 'ExistingUser'} -> {name: 'FAIL_UP_MIGRATION'}
+		// 3. UP migration: {name: 'FAIL_UP_MIGRATION'} -> THROWS
+		// This tests line 972 in TLSyncRoom.ts
+		server.room.handleMessage(sessionId, {
+			type: 'push',
+			clientClock: 1,
+			diff: {
+				[existingUser.id]: [RecordOpType.Patch, { name: [ValueOpType.Put, 'FAIL_UP_MIGRATION'] }],
+			},
+		})
+
+		// Session should be rejected due to UP migration failure during patch
+		expect(socket.close).toHaveBeenCalledWith(4099, TLSyncErrorCloseEventReason.CLIENT_TOO_OLD)
+	})
+})
+
 describe('when the client is the same version', () => {
 	function setup() {
 		const steve = UserV2.create({

package/src/test/validation.test.ts

@@ -95,7 +95,7 @@ async function makeTestInstance() {
 it('rejects invalid put operations that create a new document', async () => {
 	const { client, flush, onSyncError, server } = await makeTestInstance()
 
-	const prevServerDocs = server.room.getSnapshot().documents
+	const prevServerDocs = server.storage.getSnapshot().documents
 
 	client.store.put([
 		{
@@ -109,20 +109,20 @@ it('rejects invalid put operations that create a new document', async () => {
 
 	expect(onSyncError).toHaveBeenCalledTimes(1)
 	expect(onSyncError).toHaveBeenLastCalledWith(TLSyncErrorCloseEventReason.INVALID_RECORD)
-	expect(server.room.getSnapshot().documents).toStrictEqual(prevServerDocs)
+	expect(server.storage.getSnapshot().documents).toStrictEqual(prevServerDocs)
 })
 
 it('rejects invalid put operations that replace an existing document', async () => {
 	const { client, flush, onSyncError, server } = await makeTestInstance()
 
-	let prevServerDocs = server.room.getSnapshot().documents
+	let prevServerDocs = server.storage.getSnapshot().documents
 	const book: Book = { typeName: 'book', id: Book.createId('1'), title: 'Annihilation' }
 	client.store.put([book])
 	await flush()
 
 	expect(onSyncError).toHaveBeenCalledTimes(0)
-	expect(server.room.getSnapshot().documents).not.toStrictEqual(prevServerDocs)
-	prevServerDocs = server.room.getSnapshot().documents
+	expect(server.storage.getSnapshot().documents).not.toStrictEqual(prevServerDocs)
+	prevServerDocs = server.storage.getSnapshot().documents
 
 	client.socket.sendMessage({
 		type: 'push',
@@ -143,13 +143,13 @@ it('rejects invalid put operations that replace an existing document', async ()
 
 	expect(onSyncError).toHaveBeenCalledTimes(1)
 	expect(onSyncError).toHaveBeenLastCalledWith(TLSyncErrorCloseEventReason.INVALID_RECORD)
-	expect(server.room.getSnapshot().documents).toStrictEqual(prevServerDocs)
+	expect(server.storage.getSnapshot().documents).toStrictEqual(prevServerDocs)
 })
 
 it('rejects invalid update operations', async () => {
 	const { client, flush, onSyncError, server } = await makeTestInstance()
 
-	let prevServerDocs = server.room.getSnapshot().documents
+	let prevServerDocs = server.storage.getSnapshot().documents
 
 	// create the book
 	client.store.put([
@@ -162,8 +162,8 @@ it('rejects invalid update operations', async () => {
 	await flush()
 
 	expect(onSyncError).toHaveBeenCalledTimes(0)
-	expect(server.room.getSnapshot().documents).not.toStrictEqual(prevServerDocs)
-	prevServerDocs = server.room.getSnapshot().documents
+	expect(server.storage.getSnapshot().documents).not.toStrictEqual(prevServerDocs)
+	prevServerDocs = server.storage.getSnapshot().documents
 
 	// update the title to be wrong
 	client.store.put([
@@ -177,5 +177,5 @@ it('rejects invalid update operations', async () => {
 	await flush()
 	expect(onSyncError).toHaveBeenCalledTimes(1)
 	expect(onSyncError).toHaveBeenLastCalledWith(TLSyncErrorCloseEventReason.INVALID_RECORD)
-	expect(server.room.getSnapshot().documents).toStrictEqual(prevServerDocs)
+	expect(server.storage.getSnapshot().documents).toStrictEqual(prevServerDocs)
 })

package/src/test/pruneTombstones.test.ts

@@ -1,178 +0,0 @@
-import { BaseRecord, createRecordType, RecordId, StoreSchema } from '@tldraw/store'
-import { TLSyncRoom } from '../lib/TLSyncRoom'
-import { findMin } from '../lib/findMin'
-
-interface TestRecord extends BaseRecord<'test', RecordId<TestRecord>> {
-	name: string
-}
-
-describe('TLSyncRoom pruneTombstones', () => {
-	let room: TLSyncRoom<TestRecord, any>
-	let TestRecordType: any
-	let schema: StoreSchema<TestRecord, any>
-
-	beforeEach(() => {
-		TestRecordType = createRecordType<TestRecord>('test', {
-			scope: 'document',
-		})
-
-		schema = StoreSchema.create({
-			test: TestRecordType,
-		})
-
-		// Create room with empty snapshot to avoid default documents being converted to tombstones
-		room = new TLSyncRoom({
-			schema,
-			snapshot: {
-				clock: 0,
-				documents: [],
-			},
-		})
-	})
-
-	it('should not prune when tombstone count is below threshold', () => {
-		// Add some tombstones but below MAX_TOMBSTONES (3000)
-		for (let i = 0; i < 100; i++) {
-			room.tombstones.set(`doc${i}`, i + 1)
-		}
-
-		const initialSize = room.tombstones.size
-		const initialHistoryClock = room.tombstoneHistoryStartsAtClock
-
-		// Reset needsPrune flag and call pruneTombstones
-		;(room as any).needsPrune = true
-		;(room as any).pruneTombstones()
-
-		// Should not have pruned anything
-		expect(room.tombstones.size).toBe(initialSize)
-		expect(room.tombstoneHistoryStartsAtClock).toBe(initialHistoryClock)
-
-		expect(findMin(room.tombstones.values())).toBeGreaterThanOrEqual(
-			room.tombstoneHistoryStartsAtClock
-		)
-	})
-
-	it('should prune tombstones when count exceeds threshold', () => {
-		// Add more tombstones than MAX_TOMBSTONES
-		const totalTombstones = 3200 // Above MAX_TOMBSTONES (3000)
-		for (let i = 0; i < totalTombstones; i++) {
-			room.tombstones.set(`doc${i}`, i + 1)
-		}
-
-		const startCock = room.tombstoneHistoryStartsAtClock
-
-		expect(room.tombstones.size).toBe(totalTombstones)
-
-		// Reset needsPrune flag and call pruneTombstones
-		;(room as any).needsPrune = true
-		;(room as any).pruneTombstones()
-
-		expect(room.tombstones.size).toBeLessThan(totalTombstones)
-		expect(room.tombstoneHistoryStartsAtClock).toBeGreaterThan(startCock)
-
-		expect(room.tombstones.size).toMatchInlineSnapshot(`2700`) // should be about 1500
-		expect(room.tombstoneHistoryStartsAtClock).toMatchInlineSnapshot(`501`) // should be about 1700
-
-		expect(findMin(room.tombstones.values())).toBeGreaterThanOrEqual(
-			room.tombstoneHistoryStartsAtClock
-		)
-	})
-
-	it('should handle tombstones with same clock value correctly', () => {
-		// Add tombstones with some having the same clock values
-		const totalTombstones = 3200
-		for (let i = 0; i < totalTombstones; i++) {
-			// Use clock values that repeat: 1, 1, 1, ..., 2, 2, 2, ..., 320, 320, 320
-			const clock = Math.floor(i / 10) + 1
-			room.tombstones.set(`doc${i}`, clock)
-		}
-
-		const startCock = room.tombstoneHistoryStartsAtClock
-
-		// Reset needsPrune flag and call pruneTombstones
-		;(room as any).needsPrune = true
-		;(room as any).pruneTombstones()
-
-		// The algorithm keeps the oldest tombstones (preserving history)
-		// With repeating clock values, we have 10 tombstones for each clock 1-320
-		// We keep the oldest 200 tombstones (clocks 1-20)
-		// We delete the newest 3000 tombstones (clocks 21-320)
-		expect(room.tombstones.size).toBeLessThan(totalTombstones)
-		expect(room.tombstoneHistoryStartsAtClock).toBeGreaterThan(startCock)
-
-		expect(room.tombstones.size).toMatchInlineSnapshot(`2700`) // should be about 1500
-		expect(room.tombstoneHistoryStartsAtClock).toMatchInlineSnapshot(`51`) // should be about 150
-
-		expect(findMin(room.tombstones.values())).toBeGreaterThanOrEqual(
-			room.tombstoneHistoryStartsAtClock
-		)
-	})
-
-	it('should handle edge case where all tombstones have same clock value', () => {
-		// Add tombstones all with the same clock value
-		const totalTombstones = 3200
-		const sameClock = 100
-		for (let i = 0; i < totalTombstones; i++) {
-			room.tombstones.set(`doc${i}`, sameClock)
-		}
-
-		const startClock = room.tombstoneHistoryStartsAtClock
-
-		// Reset needsPrune flag and call pruneTombstones
-		;(room as any).needsPrune = true
-		;(room as any).pruneTombstones()
-
-		// When all tombstones have the same clock value, the algorithm deletes all of them
-		// because the while loop advances to the end and all tombstones are marked for deletion
-		expect(room.tombstones.size).toBeLessThan(totalTombstones)
-		expect(room.tombstoneHistoryStartsAtClock).toBeGreaterThan(startClock)
-
-		expect(room.tombstones.size).toMatchInlineSnapshot(`0`) // all deleted
-		expect(room.tombstoneHistoryStartsAtClock).toMatchInlineSnapshot(`101`) // next clock after deletion
-
-		expect(findMin(room.tombstones.values())).toBe(null) // findMin returns null for empty collections
-	})
-
-	it('should handle exact threshold case', () => {
-		// Add exactly MAX_TOMBSTONES tombstones
-		for (let i = 0; i < 3000; i++) {
-			room.tombstones.set(`doc${i}`, i + 1)
-		}
-
-		const initialSize = room.tombstones.size
-		expect(initialSize).toBe(3000)
-
-		// Reset needsPrune flag and call pruneTombstones
-		;(room as any).needsPrune = true
-		;(room as any).pruneTombstones()
-
-		// Should not prune anything since we're exactly at the threshold
-		expect(room.tombstones.size).toBe(initialSize)
-	})
-
-	it('should handle very large tombstone counts', () => {
-		// Test with a much larger number of tombstones
-		const totalTombstones = 10000
-		for (let i = 0; i < totalTombstones; i++) {
-			room.tombstones.set(`doc${i}`, i + 1)
-		}
-
-		const startClock = room.tombstoneHistoryStartsAtClock
-
-		// Reset needsPrune flag and call pruneTombstones
-		;(room as any).needsPrune = true
-		;(room as any).pruneTombstones()
-
-		// The algorithm keeps the oldest tombstones (preserving history)
-		// With 10000 tombstones, we keep about 7000 and delete about 3000
-		expect(room.tombstones.size).toBeLessThan(totalTombstones)
-		expect(room.tombstoneHistoryStartsAtClock).toBeGreaterThan(startClock)
-
-		expect(room.tombstones.size).toMatchInlineSnapshot(`2700`) // should be about 1500
-		expect(room.tombstoneHistoryStartsAtClock).toMatchInlineSnapshot(`7301`) // should be about 1500
-
-		expect(findMin(room.tombstones.values())).toBeGreaterThanOrEqual(
-			room.tombstoneHistoryStartsAtClock
-		)
-	})
-})