@tldraw/sync-core 4.2.2 → 4.2.3

package/src/test/TestServer.ts

@@ -1,22 +1,11 @@
 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) {
-		// 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 })
+		this.room = new TLSyncRoom<R, undefined>({ schema, snapshot })
 	}
 
 	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<any, any>({ schema, props: {} })
+		const store = new Store({ 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.presenceStore.get(session!.presenceId!)).toMatchObject({
+	expect(t.server.room.documents.get(session!.presenceId!)?.state).toMatchObject({
 		name: 'bob',
 		age: 10,
 	})
 
 	presenceSignal.set(Presence.create({ name: 'bob', age: 11 }))
 	t.flush()
-	expect(t.server.room.presenceStore.get(session!.presenceId!)).toMatchObject({
+	expect(t.server.room.documents.get(session!.presenceId!)?.state).toMatchObject({
 		name: 'bob',
 		age: 11,
 	})
 
 	presenceSignal.set(Presence.create({ name: 'bob', age: 12 }))
 	t.flush()
-	expect(t.server.room.presenceStore.get(session!.presenceId!)).toMatchObject({
+	expect(t.server.room.documents.get(session!.presenceId!)?.state).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.presenceStore.get(session!.presenceId!)).toMatchObject({
+	expect(t.server.room.documents.get(session!.presenceId!)?.state).toMatchObject({
 		name: 'bob',
 		age: 10,
 	})
 
 	presenceSignal.set(Presence.create({ name: 'bob', age: 11 }))
 	t.flush()
-	expect(t.server.room.presenceStore.get(session!.presenceId!)).not.toMatchObject({
+	expect(t.server.room.documents.get(session!.presenceId!)?.state).not.toMatchObject({
 		name: 'bob',
 		age: 11,
 	})
 
 	presenceSignal.set(Presence.create({ name: 'bob', age: 12 }))
 	t.flush()
-	expect(t.server.room.presenceStore.get(session!.presenceId!)).not.toMatchObject({
+	expect(t.server.room.documents.get(session!.presenceId!)?.state).not.toMatchObject({
 		name: 'bob',
 		age: 12,
 	})

package/src/test/pruneTombstones.test.ts

@@ -0,0 +1,178 @@
+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
+		)
+	})
+})

package/src/test/syncFuzz.test.ts

@@ -1,5 +1,7 @@
 import {
 	Editor,
+	TLArrowBinding,
+	TLArrowShape,
 	TLRecord,
 	TLStore,
 	computed,
@@ -109,9 +111,9 @@ let totalNumShapes = 0
 let totalNumPages = 0
 
 function arrowsAreSound(editor: Editor) {
-	const arrows = editor.getCurrentPageShapes().filter((s) => s.type === 'arrow')
+	const arrows = editor.getCurrentPageShapes().filter((s): s is TLArrowShape => s.type === 'arrow')
 	for (const arrow of arrows) {
-		const bindings = editor.getBindingsFromShape(arrow, 'arrow')
+		const bindings = editor.getBindingsFromShape<TLArrowBinding>(arrow, 'arrow')
 		const terminalsSeen = new Set()
 		for (const binding of bindings) {
 			if (terminalsSeen.has(binding.props.terminal)) {

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.storage.documents.get(user.id)?.state).toMatchObject({
+	expect(t.server.room.documents.get(user.id)?.state).toMatchObject({
 		name: 'bob',
 		birthdate: null,
 	})
-	expect(t.server.storage.documents.get(user.id)?.state).not.toMatchObject({
+	expect(t.server.room.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.storage.documents.get(user.id)?.state).toMatchObject({
+	expect(t.server.room.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.storage.documents.get(bob.id)?.state).toMatchObject({
+	expect(t.server.room.documents.get(bob.id)?.state).toMatchObject({
 		name: 'bob',
 		birthdate: null,
 	})
-	expect(t.server.storage.documents.get(joe.id)).toBeUndefined()
+	expect(t.server.room.documents.get(joe.id)).toBeUndefined()
 
 	// there should be someone named steve
-	const snapshot = t.server.storage.getSnapshot()
+	const snapshot = t.server.room.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.storage.getSnapshot()
+	const snapshot = t.server.room.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.documentClock ?? snapshot.clock ?? 0,
+		lastServerClock: snapshot.clock,
 		protocolVersion: getTlsyncProtocolVersion(),
 		schema: schemaV3.serialize(),
 	})
@@ -670,288 +670,6 @@ describe('when the client is too old', () => {
 	})
 })
 
-describe('migration failure during push (TLSyncError handling)', () => {
-	let consoleSpy: ReturnType<typeof vi.spyOn>
-	beforeEach(() => {
-		consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
-	})
-	afterEach(() => {
-		consoleSpy.mockRestore()
-	})
-
-	// 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({