@tldraw/sync-core 5.2.0-canary.4a316fdfb2bb → 5.2.0-canary.4e00299c3e28

package/src/test/upgradeDowngrade.test.ts

@@ -218,7 +218,7 @@ class TestInstance {
 	}
 }
 
-test('the server can handle receiving v1 stuff from the client', () => {
+it('[MG2] the server can handle receiving v1 stuff from the client', () => {
 	const t = new TestInstance()
 	t.oldSocketPair.connect()
 	t.newSocketPair.connect()
@@ -244,7 +244,7 @@ test('the server can handle receiving v1 stuff from the client', () => {
 	expect(t.newClient.store.get(user.id as any)).not.toMatchObject({ name: 'bob', age: 10 })
 })
 
-test('the server can send v2 stuff to the v1 client', () => {
+it('[MG1] the server can send v2 stuff to the v1 client', () => {
 	const t = new TestInstance()
 	t.oldSocketPair.connect()
 	t.newSocketPair.connect()
@@ -269,7 +269,7 @@ test('the server can send v2 stuff to the v1 client', () => {
 	})
 })
 
-test('the server will run schema migrations on a snapshot', () => {
+it('[RC3] the server will run schema migrations on a snapshot', () => {
 	const bob = UserV1.create({ name: 'bob', age: 10 })
 	// joe will be deleted
 	const joe = UserV1.create({ name: 'joe', age: 10 })
@@ -298,7 +298,7 @@ test('the server will run schema migrations on a snapshot', () => {
 	expect(snapshot.documents.find((u: any) => u.state.name === 'steve')).toBeDefined()
 })
 
-test('clients will receive updates from a snapshot migration upon connection', () => {
+it('[MG1] clients will receive updates from a snapshot migration upon connection', () => {
 	const t = new TestInstance()
 	t.oldSocketPair.connect()
 	t.newSocketPair.connect()
@@ -347,7 +347,7 @@ test('clients will receive updates from a snapshot migration upon connection', (
 	})
 })
 
-test('out-of-date clients will receive incompatibility errors', () => {
+it('[HS3] out-of-date clients will receive incompatibility errors', () => {
 	const v3server = new TestServer(schemaV3)
 
 	const id = 'test_upgrade_v2'
@@ -365,7 +365,7 @@ test('out-of-date clients will receive incompatibility errors', () => {
 	expect(socket.close).toHaveBeenCalledWith(4099, TLSyncErrorCloseEventReason.CLIENT_TOO_OLD)
 })
 
-test('clients using an out-of-date protocol will receive compatibility errors', () => {
+it('[HS2] clients using an out-of-date protocol will receive compatibility errors', () => {
 	const actualVersion = getTlsyncProtocolVersion()
 	mockGetTlsyncProtocolVersion.mockReturnValue(actualVersion + 1)
 	try {
@@ -390,14 +390,12 @@ test('clients using an out-of-date protocol will receive compatibility errors',
 	}
 })
 
-// this can be deleted when the protocol gets to v7
-test('v5 special case should allow connections', () => {
-	const actualVersion = getTlsyncProtocolVersion()
-	if (actualVersion > 6) return
-
+// protocol v5 is treated as v6: accepted, but with the legacy rejection scheme
+// and without string-append support
+it('[HS2] v5 special case should allow connections', () => {
 	const v2server = new TestServer(schemaV2)
 
-	const id = 'test_upgrade_v3'
+	const id = 'test_upgrade_v5'
 	const socket = mockSocket()
 
 	v2server.room.handleNewSession({ sessionId: id, socket, meta: undefined, isReadonly: false })
@@ -409,24 +407,21 @@ test('v5 special case should allow connections', () => {
 		schema: schemaV2.serialize(),
 	})
 
-	expect(socket.sendMessage).toHaveBeenCalledWith({
-		connectRequestId: 'test',
-		diff: {},
-		hydrationType: 'wipe_all',
-		protocolVersion: 6,
-		schema: {
-			schemaVersion: 2,
-			sequences: {
-				'com.tldraw.user': 1,
-			},
-		},
-		serverClock: 1,
+	expect(socket.close).not.toHaveBeenCalled()
+	expect((socket.sendMessage as Mock).mock.calls[0][0]).toMatchObject({
 		type: 'connect',
+		connectRequestId: 'test',
+		protocolVersion: getTlsyncProtocolVersion(),
 		isReadonly: false,
-	} satisfies TLSocketServerSentEvent<RV2>)
+	})
+
+	const session = v2server.room.sessions.get(id) as any
+	expect(session?.state).toBe('connected')
+	expect(session?.requiresLegacyRejection).toBe(true)
+	expect(session?.supportsStringAppend).toBe(false)
 })
 
-test('clients using a too-new protocol will receive compatibility errors', () => {
+it('[HS2] clients using a too-new protocol will receive compatibility errors', () => {
 	const v2server = new TestServer(schemaV2)
 
 	const id = 'test_upgrade_v3'
@@ -444,7 +439,7 @@ test('clients using a too-new protocol will receive compatibility errors', () =>
 	expect(socket.close).toHaveBeenCalledWith(4099, TLSyncErrorCloseEventReason.SERVER_TOO_OLD)
 })
 
-test('when the client is too new it cannot connect', () => {
+it('[HS3] when the client is too new it cannot connect', () => {
 	const steve = UserV1.create({ id: UserV1.createId('steve'), name: 'steve', age: 23 })
 	const jeff = UserV1.create({ id: UserV1.createId('jeff'), name: 'jeff', age: 23 })
 	const annie = UserV1.create({ id: UserV1.createId('annie'), name: 'annie', age: 23 })
@@ -607,8 +602,8 @@ describe('when the client is too old', () => {
 		data = setup()
 	})
 
-	it('allows deletions from v1 client', () => {
-		data.v2Server.room.handleMessage(data.v2Id, {
+	it('[MG2] allows deletions from v1 client', () => {
+		data.v2Server.room.handleMessage(data.v1Id, {
 			type: 'push',
 			clientClock: 1,
 			diff: {
@@ -616,7 +611,7 @@ describe('when the client is too old', () => {
 			},
 		})
 
-		expect(data.v2SendMessage).toHaveBeenCalledWith({
+		expect(data.v1SendMessage).toHaveBeenCalledWith({
 			type: 'data',
 			data: [
 				{
@@ -627,9 +622,22 @@ describe('when the client is too old', () => {
 				},
 			],
 		} satisfies TLSocketServerSentEvent<RV2>)
+
+		expect(data.v2SendMessage).toHaveBeenCalledWith({
+			type: 'data',
+			data: [
+				{
+					type: 'patch',
+					diff: {
+						[data.steve.id]: [RecordOpType.Remove],
+					},
+					serverClock: 11,
+				},
+			],
+		} satisfies TLSocketServerSentEvent<RV2>)
 	})
 
-	it('can handle patches from older clients', () => {
+	it('[MG2] can handle patches from older clients', () => {
 		data.v2Server.room.handleMessage(data.v1Id, {
 			type: 'push',
 			clientClock: 1,
@@ -670,7 +678,7 @@ describe('when the client is too old', () => {
 	})
 })
 
-describe('migration failure during push (TLSyncError handling)', () => {
+describe('migration failure (TLSyncError handling)', () => {
 	let consoleSpy: ReturnType<typeof vi.spyOn>
 	beforeEach(() => {
 		consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
@@ -755,7 +763,7 @@ describe('migration failure during push (TLSyncError handling)', () => {
 		}
 	)
 
-	it('rejects session when addDocument UP migration throws during PUT', () => {
+	it('[MG2] rejects session when addDocument up migration throws during put', () => {
 		const server = new TestServer(serverSchemaWithThrowingMigration)
 
 		const sessionId = 'failing-migration-session'
@@ -798,7 +806,7 @@ describe('migration failure during push (TLSyncError handling)', () => {
 		expect(socket.close).toHaveBeenCalledWith(4099, TLSyncErrorCloseEventReason.CLIENT_TOO_OLD)
 	})
 
-	it('successfully migrates records when migration does not throw', () => {
+	it('[MG2] successfully migrates records when migration does not throw', () => {
 		const server = new TestServer(serverSchemaWithThrowingMigration)
 
 		const sessionId = 'successful-migration-session'
@@ -846,7 +854,7 @@ describe('migration failure during push (TLSyncError handling)', () => {
 		expect(storedRecord.nickname).toBe('VALIDNAME') // Uppercase from migration
 	})
 
-	it('rejects session when patchDocument DOWN migration throws', () => {
+	it('[MG2] 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'),
@@ -897,7 +905,7 @@ describe('migration failure during push (TLSyncError handling)', () => {
 		expect(socket.close).toHaveBeenCalledWith(4099, TLSyncErrorCloseEventReason.CLIENT_TOO_OLD)
 	})
 
-	it('rejects session when patchDocument UP migration throws (after successful DOWN migration)', () => {
+	it('[MG2] 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'),
@@ -950,6 +958,84 @@ describe('migration failure during push (TLSyncError handling)', () => {
 		// Session should be rejected due to UP migration failure during patch
 		expect(socket.close).toHaveBeenCalledWith(4099, TLSyncErrorCloseEventReason.CLIENT_TOO_OLD)
 	})
+
+	it('[MG1] rejects only the affected session when down migration fails during broadcast', () => {
+		const server = new TestServer(serverSchemaWithThrowingMigration)
+
+		// An old-schema client whose outgoing diffs require down migration
+		const oldId = 'broadcast-old-schema-session'
+		const oldSocket = mockSocket<UserWithNickname>()
+		server.room.handleNewSession({
+			sessionId: oldId,
+			socket: oldSocket as any,
+			meta: undefined,
+			isReadonly: false,
+		})
+		server.room.handleMessage(oldId, {
+			type: 'connect',
+			connectRequestId: 'test',
+			lastServerClock: 0,
+			protocolVersion: getTlsyncProtocolVersion(),
+			schema: clientSchemaWithoutNickname.serialize(),
+		})
+
+		// An up-to-date client that pushes a record whose down migration throws
+		const newId = 'broadcast-new-schema-session'
+		const newSocket = mockSocket<UserWithNickname>()
+		server.room.handleNewSession({
+			sessionId: newId,
+			socket: newSocket as any,
+			meta: undefined,
+			isReadonly: false,
+		})
+		server.room.handleMessage(newId, {
+			type: 'connect',
+			connectRequestId: 'test',
+			lastServerClock: 0,
+			protocolVersion: getTlsyncProtocolVersion(),
+			schema: serverSchemaWithThrowingMigration.serialize(),
+		})
+
+		expect(server.room.sessions.get(oldId)?.state).toBe('connected')
+		expect(server.room.sessions.get(newId)?.state).toBe('connected')
+		;(oldSocket.sendMessage as Mock).mockClear()
+		;(newSocket.sendMessage as Mock).mockClear()
+
+		const failingRecord = UserWithNicknameType.create({
+			id: UserWithNicknameType.createId('broadcast_fail'),
+			name: 'BroadcastUser',
+			nickname: 'FAIL_DOWN_MIGRATION', // triggers the DOWN throw when broadcast to old client
+		})
+
+		server.room.handleMessage(newId, {
+			type: 'push',
+			clientClock: 1,
+			diff: {
+				[failingRecord.id]: [RecordOpType.Put, failingRecord as any],
+			},
+		})
+
+		// The push itself succeeds: the record is stored and the pusher gets a commit
+		expect(server.storage.documents.get(failingRecord.id)?.state).toMatchObject({
+			nickname: 'FAIL_DOWN_MIGRATION',
+		})
+		expect(newSocket.close).not.toHaveBeenCalled()
+		expect(newSocket.sendMessage).toHaveBeenCalledWith({
+			type: 'data',
+			data: [
+				{
+					type: 'push_result',
+					action: 'commit',
+					clientClock: 1,
+					serverClock: 1,
+				},
+			],
+		})
+
+		// Only the old-schema session is rejected, because broadcasting the put to it
+		// requires a down migration that throws
+		expect(oldSocket.close).toHaveBeenCalledWith(4099, TLSyncErrorCloseEventReason.CLIENT_TOO_OLD)
+	})
 })
 
 describe('when the client is the same version', () => {
@@ -1045,7 +1131,21 @@ describe('when the client is the same version', () => {
 		data = setup()
 	})
 
-	it('sends minimal patches', () => {
+	it('[MG3] accepts client with same schema version', () => {
+		// both clients connected with a deep-equal (but not reference-equal) serialized
+		// schema; they are accepted (see setup assertions) and share the server's schema
+		// object so migration is skipped entirely
+		const aSession = data.v2Server.room.sessions.get(data.aId) as any
+		const bSession = data.v2Server.room.sessions.get(data.bId) as any
+		expect(aSession?.state).toBe('connected')
+		expect(bSession?.state).toBe('connected')
+		expect(aSession?.serializedSchema).toBe(data.v2Server.room.serializedSchema)
+		expect(bSession?.serializedSchema).toBe(data.v2Server.room.serializedSchema)
+		expect(aSession?.requiresDownMigrations).toBe(false)
+		expect(bSession?.requiresDownMigrations).toBe(false)
+	})
+
+	it('[MG3] sends minimal patches', () => {
 		data.v2Server.room.handleMessage(data.aId, {
 			type: 'push',
 			clientClock: 1,

package/src/lib/NodeSqliteSyncWrapper.integration.test.ts

@@ -1,270 +0,0 @@
-import { DatabaseSync } from 'node:sqlite'
-import { RecordId, StoreSchema } from 'tldraw'
-import { beforeEach, describe, expect, it } from 'vitest'
-import { NodeSqliteWrapper } from './NodeSqliteWrapper'
-import { migrateSqliteSyncStorage, SQLiteSyncStorage } from './SQLiteSyncStorage'
-import { RoomSnapshot } from './TLSyncRoom'
-
-// Simple record type for testing
-interface TestRecord {
-	id: RecordId<TestRecord>
-	typeName: string
-	name: string
-	value: number
-}
-
-type ID = RecordId<TestRecord>
-
-// SQLiteSyncStorage uses multi-statement DDL in constructor which node:sqlite
-// doesn't support (prepare() only handles one statement). We need to initialize
-// the tables separately before creating the storage.
-function initializeTables(db: DatabaseSync) {
-	migrateSqliteSyncStorage(new NodeSqliteWrapper(db))
-}
-
-const defaultSnapshot: RoomSnapshot = {
-	documents: [],
-	tombstones: {},
-	schema: StoreSchema.create({}).serialize(),
-}
-
-describe('NodeSqliteSyncWrapper + SQLiteSyncStorage integration', () => {
-	let db: DatabaseSync
-	let sql: NodeSqliteWrapper
-	let storage: SQLiteSyncStorage<TestRecord>
-
-	beforeEach(() => {
-		db = new DatabaseSync(':memory:')
-		initializeTables(db)
-		sql = new NodeSqliteWrapper(db)
-		// Pass undefined snapshot since we already initialized the tables
-		storage = new SQLiteSyncStorage<TestRecord>({
-			sql,
-			snapshot: defaultSnapshot,
-		})
-	})
-
-	describe('basic operations', () => {
-		it('can set and get a record', () => {
-			const record: TestRecord = { id: 'test-1' as ID, typeName: 'test', name: 'Alice', value: 100 }
-
-			storage.transaction((txn) => {
-				txn.set(record.id, record)
-			})
-
-			const result = storage.transaction((txn) => txn.get('test-1'))
-			expect(result.result).toEqual(record)
-		})
-
-		it('can delete a record', () => {
-			const record: TestRecord = { id: 'test-1' as ID, typeName: 'test', name: 'Alice', value: 100 }
-
-			storage.transaction((txn) => {
-				txn.set(record.id, record)
-			})
-
-			storage.transaction((txn) => {
-				txn.delete('test-1')
-			})
-
-			const result = storage.transaction((txn) => txn.get('test-1'))
-			expect(result.result).toBeUndefined()
-		})
-
-		it('increments clock on mutations', () => {
-			expect(storage.getClock()).toBe(0)
-
-			storage.transaction((txn) => {
-				txn.set('test-1', { id: 'test-1' as ID, typeName: 'test', name: 'Alice', value: 100 })
-			})
-
-			expect(storage.getClock()).toBe(1)
-
-			storage.transaction((txn) => {
-				txn.set('test-2', { id: 'test-2' as ID, typeName: 'test', name: 'Bob', value: 200 })
-			})
-
-			expect(storage.getClock()).toBe(2)
-		})
-
-		it('only increments clock once per transaction', () => {
-			storage.transaction((txn) => {
-				txn.set('test-1', { id: 'test-1' as ID, typeName: 'test', name: 'Alice', value: 100 })
-				txn.set('test-2', { id: 'test-2' as ID, typeName: 'test', name: 'Bob', value: 200 })
-				txn.set('test-3', { id: 'test-3' as ID, typeName: 'test', name: 'Charlie', value: 300 })
-			})
-
-			expect(storage.getClock()).toBe(1)
-		})
-	})
-
-	describe('iteration', () => {
-		it('can iterate over entries', () => {
-			storage.transaction((txn) => {
-				txn.set('test-1', { id: 'test-1' as ID, typeName: 'test', name: 'Alice', value: 100 })
-				txn.set('test-2', { id: 'test-2' as ID, typeName: 'test', name: 'Bob', value: 200 })
-			})
-
-			const entries = storage.transaction((txn) => [...txn.entries()])
-			expect(entries.result).toHaveLength(2)
-			expect(entries.result.map(([id]) => id).sort()).toEqual(['test-1', 'test-2'])
-		})
-
-		it('can iterate over keys', () => {
-			storage.transaction((txn) => {
-				txn.set('test-1', { id: 'test-1' as ID, typeName: 'test', name: 'Alice', value: 100 })
-				txn.set('test-2', { id: 'test-2' as ID, typeName: 'test', name: 'Bob', value: 200 })
-			})
-
-			const keys = storage.transaction((txn) => [...txn.keys()])
-			expect(keys.result.sort()).toEqual(['test-1', 'test-2'])
-		})
-
-		it('can iterate over values', () => {
-			storage.transaction((txn) => {
-				txn.set('test-1', { id: 'test-1' as ID, typeName: 'test', name: 'Alice', value: 100 })
-				txn.set('test-2', { id: 'test-2' as ID, typeName: 'test', name: 'Bob', value: 200 })
-			})
-
-			const values = storage.transaction((txn) => [...txn.values()])
-			expect(values.result).toHaveLength(2)
-			expect(values.result.map((v) => v.name).sort()).toEqual(['Alice', 'Bob'])
-		})
-	})
-
-	describe('snapshots', () => {
-		it('can get a snapshot', () => {
-			storage.transaction((txn) => {
-				txn.set('test-1', { id: 'test-1' as ID, typeName: 'test', name: 'Alice', value: 100 })
-			})
-
-			const snapshot = storage.getSnapshot()
-
-			expect(snapshot.documentClock).toBe(1)
-			expect(snapshot.documents).toHaveLength(1)
-			expect(snapshot.documents[0].state).toEqual({
-				id: 'test-1',
-				typeName: 'test',
-				name: 'Alice',
-				value: 100,
-			})
-			expect(snapshot.schema).toEqual(defaultSnapshot.schema)
-		})
-
-		it('includes tombstones in snapshot', () => {
-			storage.transaction((txn) => {
-				txn.set('test-1', { id: 'test-1' as ID, typeName: 'test', name: 'Alice', value: 100 })
-			})
-
-			storage.transaction((txn) => {
-				txn.delete('test-1')
-			})
-
-			const snapshot = storage.getSnapshot()
-
-			expect(snapshot.documents).toHaveLength(0)
-			expect(snapshot.tombstones).toEqual({ 'test-1': 2 })
-		})
-	})
-
-	describe('getChangesSince', () => {
-		it('returns changes since a given clock', () => {
-			storage.transaction((txn) => {
-				txn.set('test-1', { id: 'test-1' as ID, typeName: 'test', name: 'Alice', value: 100 })
-			})
-
-			const clock1 = storage.getClock()
-
-			storage.transaction((txn) => {
-				txn.set('test-2', { id: 'test-2' as ID, typeName: 'test', name: 'Bob', value: 200 })
-			})
-
-			const changes = storage.transaction((txn) => txn.getChangesSince(clock1))
-
-			expect(changes.result?.diff.puts).toHaveProperty('test-2')
-			expect(changes.result?.diff.puts).not.toHaveProperty('test-1')
-		})
-
-		it('includes deletes in changes', () => {
-			storage.transaction((txn) => {
-				txn.set('test-1', { id: 'test-1' as ID, typeName: 'test', name: 'Alice', value: 100 })
-			})
-
-			const clock1 = storage.getClock()
-
-			storage.transaction((txn) => {
-				txn.delete('test-1')
-			})
-
-			const changes = storage.transaction((txn) => txn.getChangesSince(clock1))
-
-			expect(changes.result?.diff.deletes).toContain('test-1')
-		})
-
-		it('returns undefined when no changes', () => {
-			storage.transaction((txn) => {
-				txn.set('test-1', { id: 'test-1' as ID, typeName: 'test', name: 'Alice', value: 100 })
-			})
-
-			const clock = storage.getClock()
-
-			const changes = storage.transaction((txn) => txn.getChangesSince(clock))
-
-			expect(changes.result).toBeUndefined()
-		})
-	})
-
-	describe('transaction rollback', () => {
-		it('rolls back on error', () => {
-			storage.transaction((txn) => {
-				txn.set('test-1', { id: 'test-1' as ID, typeName: 'test', name: 'Alice', value: 100 })
-			})
-
-			expect(() => {
-				storage.transaction((txn) => {
-					txn.set('test-2', { id: 'test-2' as ID, typeName: 'test', name: 'Bob', value: 200 })
-					throw new Error('oops')
-				})
-			}).toThrow('oops')
-
-			// test-2 should not exist
-			const result = storage.transaction((txn) => txn.get('test-2'))
-			expect(result.result).toBeUndefined()
-
-			// test-1 should still exist
-			const result1 = storage.transaction((txn) => txn.get('test-1'))
-			expect(result1.result?.name).toBe('Alice')
-		})
-	})
-
-	describe('onChange', () => {
-		it('notifies on changes', async () => {
-			const changes: { id?: string; documentClock: number }[] = []
-			storage.onChange((change) => {
-				changes.push(change)
-			})
-
-			storage.transaction((txn) => {
-				txn.set('test-1', { id: 'test-1' as ID, typeName: 'test', name: 'Alice', value: 100 })
-			})
-
-			// onChange uses microtask, so wait for it
-			await new Promise((resolve) => setTimeout(resolve, 0))
-
-			expect(changes).toHaveLength(1)
-			expect(changes[0].documentClock).toBe(1)
-		})
-	})
-
-	describe('hasBeenInitialized', () => {
-		it('returns true for initialized storage', () => {
-			expect(SQLiteSyncStorage.hasBeenInitialized(sql)).toBe(true)
-		})
-
-		it('returns false for uninitialized storage', () => {
-			const freshDb = new DatabaseSync(':memory:')
-			const freshWrapper = new NodeSqliteWrapper(freshDb)
-			expect(SQLiteSyncStorage.hasBeenInitialized(freshWrapper)).toBe(false)
-		})
-	})
-})

package/src/lib/RoomSession.test.ts

@@ -1,101 +0,0 @@
-import { SerializedSchema } from '@tldraw/store'
-import { TLRecord } from '@tldraw/tlschema'
-import { describe, expect, it, vi } from 'vitest'
-import {
-	RoomSession,
-	RoomSessionState,
-	SESSION_IDLE_TIMEOUT,
-	SESSION_REMOVAL_WAIT_TIME,
-	SESSION_START_WAIT_TIME,
-} from './RoomSession'
-import { TLRoomSocket } from './TLSyncRoom'
-
-// Mock socket implementation for testing
-const createMockSocket = (): TLRoomSocket<TLRecord> => ({
-	isOpen: true,
-	sendMessage: vi.fn(),
-	close: vi.fn(),
-})
-
-// Mock serialized schema for testing
-const mockSerializedSchema: SerializedSchema = {
-	schemaVersion: 1,
-	storeVersion: 1,
-	recordVersions: {},
-}
-
-describe('RoomSession timeout constants', () => {
-	it('should have logical timeout ordering for session management', () => {
-		// This test ensures the timeout constants have a logical relationship
-		// that supports proper session lifecycle management:
-		// - Quick cleanup for disconnected sessions
-		// - Reasonable wait time for initial connections
-		// - Patient timeout for active sessions
-		expect(SESSION_REMOVAL_WAIT_TIME).toBeLessThan(SESSION_START_WAIT_TIME)
-		expect(SESSION_START_WAIT_TIME).toBeLessThan(SESSION_IDLE_TIMEOUT)
-	})
-})
-
-describe('RoomSession state transitions', () => {
-	const baseSessionData = {
-		sessionId: 'test-session-id',
-		presenceId: 'test-presence-id',
-		socket: createMockSocket(),
-		meta: { userId: 'test-user' },
-		isReadonly: false,
-		requiresLegacyRejection: false,
-	}
-
-	it('should support complete session lifecycle', () => {
-		// Test that sessions can progress through their full lifecycle
-		// This validates the discriminated union works correctly for state management
-
-		// Start in awaiting state
-		const initialSession: RoomSession<TLRecord, { userId: string }> = {
-			state: RoomSessionState.AwaitingConnectMessage,
-			sessionStartTime: Date.now(),
-			supportsStringAppend: true,
-			...baseSessionData,
-		}
-
-		// Progress to connected state (simulates successful connection)
-		const connectedSession: RoomSession<TLRecord, { userId: string }> = {
-			state: RoomSessionState.Connected,
-			sessionId: initialSession.sessionId,
-			presenceId: initialSession.presenceId,
-			socket: initialSession.socket,
-			meta: initialSession.meta,
-			isReadonly: initialSession.isReadonly,
-			requiresLegacyRejection: initialSession.requiresLegacyRejection,
-			serializedSchema: mockSerializedSchema,
-			requiresDownMigrations: false,
-			supportsStringAppend: true,
-			lastInteractionTime: Date.now(),
-			debounceTimer: null,
-			outstandingDataMessages: [],
-		}
-
-		// End in awaiting removal state (simulates disconnection)
-		const removalSession: RoomSession<TLRecord, { userId: string }> = {
-			state: RoomSessionState.AwaitingRemoval,
-			sessionId: connectedSession.sessionId,
-			presenceId: connectedSession.presenceId,
-			socket: connectedSession.socket,
-			meta: connectedSession.meta,
-			isReadonly: connectedSession.isReadonly,
-			requiresLegacyRejection: connectedSession.requiresLegacyRejection,
-			supportsStringAppend: connectedSession.supportsStringAppend,
-			cancellationTime: Date.now(),
-		}
-
-		// Verify session ID remains consistent across state changes
-		// This is critical for tracking sessions through their lifecycle
-		expect(initialSession.sessionId).toBe(connectedSession.sessionId)
-		expect(connectedSession.sessionId).toBe(removalSession.sessionId)
-
-		// Verify state-specific properties are present when expected
-		expect(initialSession.state).toBe(RoomSessionState.AwaitingConnectMessage)
-		expect(connectedSession.state).toBe(RoomSessionState.Connected)
-		expect(removalSession.state).toBe(RoomSessionState.AwaitingRemoval)
-	})
-})