@tldraw/sync-core 5.3.0-internal.fba91ed55f6c → 5.3.0-next.4123e97459a9

package/src/lib/InMemorySyncStorage.ts

@@ -117,14 +117,6 @@ export const DEFAULT_INITIAL_SNAPSHOT = {
 export class InMemorySyncStorage<R extends UnknownRecord> implements TLSyncStorage<R> {
 	/** @internal */
 	documents: AtomMap<string, { state: R; lastChangedClock: number }>
-	/**
-	 * Object-store lane records, partitioned out of `documents` so they never appear in the
-	 * document snapshot. They share the same clock, tombstones, and transactions as documents.
-	 * @internal
-	 */
-	objects: AtomMap<string, { state: R; lastChangedClock: number }>
-	/** @internal */
-	readonly objectTypes: ReadonlySet<string>
 	/** @internal */
 	tombstones: AtomMap<string, number>
 	/** @internal */
@@ -141,38 +133,22 @@ export class InMemorySyncStorage<R extends UnknownRecord> implements TLSyncStora
 
 	constructor({
 		snapshot = DEFAULT_INITIAL_SNAPSHOT,
-		objectTypes,
 		onChange,
 	}: {
 		snapshot?: RoomSnapshot
-		/**
-		 * Record type names stored in the object-store lane. Records of these types are routed to
-		 * a separate partition: excluded from `getSnapshot()`, returned by `getObjectsSnapshot()`.
-		 */
-		objectTypes?: readonly string[]
 		onChange?(arg: TLSyncStorageOnChangeCallbackProps): unknown
 	} = {}) {
-		this.objectTypes = new Set(objectTypes ?? [])
 		const maxClockValue = Math.max(
 			0,
 			...Object.values(snapshot.tombstones ?? {}),
 			...Object.values(snapshot.documents.map((d) => d.lastChangedClock))
 		)
-		// route snapshot entries into their partitions (a seed snapshot may carry object-lane
-		// records merged in, e.g. loaded from a separate persistence lane)
-		const toEntry = (
-			d: RoomSnapshot['documents'][number]
-		): [string, { state: R; lastChangedClock: number }] => [
-			d.state.id,
-			{ state: devFreeze(d.state) as R, lastChangedClock: d.lastChangedClock },
-		]
 		this.documents = new AtomMap(
 			'room documents',
-			snapshot.documents.filter((d) => !this.objectTypes.has(d.state.typeName)).map(toEntry)
-		)
-		this.objects = new AtomMap(
-			'room objects',
-			snapshot.documents.filter((d) => this.objectTypes.has(d.state.typeName)).map(toEntry)
+			snapshot.documents.map((d) => [
+				d.state.id,
+				{ state: devFreeze(d.state) as R, lastChangedClock: d.lastChangedClock },
+			])
 		)
 		const documentClock = Math.max(maxClockValue, snapshot.documentClock ?? snapshot.clock ?? 0)
 
@@ -273,8 +249,6 @@ export class InMemorySyncStorage<R extends UnknownRecord> implements TLSyncStora
 	)
 
 	getSnapshot(): RoomSnapshot {
-		// object-lane records live in their own partition, so the document snapshot is
-		// pure-document by construction
 		return {
 			tombstoneHistoryStartsAtClock: this.tombstoneHistoryStartsAtClock.get(),
 			documentClock: this.documentClock.get(),
@@ -283,10 +257,6 @@ export class InMemorySyncStorage<R extends UnknownRecord> implements TLSyncStora
 			schema: this.schema.get(),
 		}
 	}
-
-	getObjectsSnapshot(): RoomSnapshot['documents'] {
-		return Array.from(this.objects.values())
-	}
 }
 
 /**
@@ -327,16 +297,9 @@ class InMemorySyncStorageTransaction<
 		return this._clock
 	}
 
-	/** The partition a record with this id currently lives in, if any. */
-	private mapContaining(id: string) {
-		if (this.storage.documents.has(id)) return this.storage.documents
-		if (this.storage.objects.has(id)) return this.storage.objects
-		return undefined
-	}
-
 	get(id: string): R | undefined {
 		this.assertNotClosed()
-		return (this.storage.documents.get(id) ?? this.storage.objects.get(id))?.state
+		return this.storage.documents.get(id)?.state
 	}
 
 	set(id: string, record: R): void {
@@ -347,11 +310,7 @@ class InMemorySyncStorageTransaction<
 		if (this.storage.tombstones.has(id)) {
 			this.storage.tombstones.delete(id)
 		}
-		// route by type: object-lane records live in their own partition
-		const map = this.storage.objectTypes.has(record.typeName)
-			? this.storage.objects
-			: this.storage.documents
-		map.set(id, {
+		this.storage.documents.set(id, {
 			state: devFreeze(record) as R,
 			lastChangedClock: clock,
 		})
@@ -360,43 +319,34 @@ class InMemorySyncStorageTransaction<
 	delete(id: string): void {
 		this.assertNotClosed()
 		// Only create a tombstone if the record actually exists
-		const map = this.mapContaining(id)
-		if (!map) return
+		if (!this.storage.documents.has(id)) return
 		const clock = this.getNextClock()
-		map.delete(id)
+		this.storage.documents.delete(id)
 		this.storage.tombstones.set(id, clock)
 		this.storage.pruneTombstones()
 	}
 
-	// iteration spans both partitions so schema migrations cover object-lane records too
-
 	*entries(): IterableIterator<[string, R]> {
 		this.assertNotClosed()
-		for (const map of [this.storage.documents, this.storage.objects]) {
-			for (const [id, record] of map.entries()) {
-				this.assertNotClosed()
-				yield [id, record.state]
-			}
+		for (const [id, record] of this.storage.documents.entries()) {
+			this.assertNotClosed()
+			yield [id, record.state]
 		}
 	}
 
 	*keys(): IterableIterator<string> {
 		this.assertNotClosed()
-		for (const map of [this.storage.documents, this.storage.objects]) {
-			for (const key of map.keys()) {
-				this.assertNotClosed()
-				yield key
-			}
+		for (const key of this.storage.documents.keys()) {
+			this.assertNotClosed()
+			yield key
 		}
 	}
 
 	*values(): IterableIterator<R> {
 		this.assertNotClosed()
-		for (const map of [this.storage.documents, this.storage.objects]) {
-			for (const record of map.values()) {
-				this.assertNotClosed()
-				yield record.state
-			}
+		for (const record of this.storage.documents.values()) {
+			this.assertNotClosed()
+			yield record.state
 		}
 	}
 
@@ -420,13 +370,10 @@ class InMemorySyncStorageTransaction<
 		}
 		const diff: TLSyncForwardDiff<R> = { puts: {}, deletes: [] }
 		const wipeAll = sinceClock < this.storage.tombstoneHistoryStartsAtClock.get()
-		// both partitions share the clock and tombstones, so the change feed spans both
-		for (const map of [this.storage.documents, this.storage.objects]) {
-			for (const doc of map.values()) {
-				if (wipeAll || doc.lastChangedClock > sinceClock) {
-					// For historical changes, we don't have "from" state, so use added
-					diff.puts[doc.state.id] = doc.state as R
-				}
+		for (const doc of this.storage.documents.values()) {
+			if (wipeAll || doc.lastChangedClock > sinceClock) {
+				// For historical changes, we don't have "from" state, so use added
+				diff.puts[doc.state.id] = doc.state as R
 			}
 		}
 		if (!wipeAll) {

package/src/lib/RoomSession.ts

@@ -1,5 +1,5 @@
 import { SerializedSchema, UnknownRecord } from '@tldraw/store'
-import { TLObjectStoreAccess, TLSocketServerSentDataEvent } from './protocol'
+import { TLSocketServerSentDataEvent } from './protocol'
 import { TLRoomSocket } from './TLSyncRoom'
 
 /**
@@ -78,13 +78,8 @@ export interface RoomSessionBase<R extends UnknownRecord, Meta> {
 	socket: TLRoomSocket<R>
 	/** Custom metadata associated with this session */
 	meta: Meta
-	/** Whether this session has read-only permissions for document-lane records */
+	/** Whether this session has read-only permissions */
 	isReadonly: boolean
-	/**
-	 * Write access for object-store lane record types (see `objectTypes` on the room).
-	 * Deliberately independent of `isReadonly` so "can comment but not edit" is expressible.
-	 */
-	objectAccess: TLObjectStoreAccess
 	/** Whether this session requires legacy protocol rejection handling */
 	requiresLegacyRejection: boolean
 	/** Whether this session supports string append operations */

package/src/lib/SQLiteSyncStorage.test.ts

@@ -38,33 +38,6 @@ describe('SQLiteSyncStorage', () => {
 			).toEqual(newPage)
 		})
 
-		it('[SQ1] sweeps pre-partition object-lane rows out of the documents table on reopen', () => {
-			// a database written before the objects table existed: object-lane records (here
-			// 'page' stands in) live in the documents table
-			const sql = createWrapper()
-			const storage = new SQLiteSyncStorage<TLRecord>({
-				sql,
-				snapshot: makeContractSnapshot(contractRecords),
-			})
-			const extraPage = makePage('legacy')
-			storage.transaction((txn) => txn.set(extraPage.id, extraPage))
-			expect(storage.getSnapshot().documents).toHaveLength(3)
-
-			// reopening with objectTypes moves the rows into the objects partition
-			const reopened = new SQLiteSyncStorage<TLRecord>({ sql, objectTypes: ['page'] })
-			expect(reopened.getSnapshot().documents.map((d) => d.state.typeName)).toEqual(['document'])
-			expect(
-				reopened
-					.getObjectsSnapshot()
-					.map((d) => d.state.id)
-					.sort()
-			).toEqual([contractRecords[1].id, extraPage.id].sort())
-			// lastChangedClock survives the move
-			expect(
-				reopened.getObjectsSnapshot().find((d) => d.state.id === extraPage.id)?.lastChangedClock
-			).toBe(1)
-		})
-
 		it('[SQ1] honors the table prefix', () => {
 			const sql = createWrapper({ tablePrefix: 'tldraw_' })
 			const storage = new SQLiteSyncStorage<TLRecord>({
@@ -254,13 +227,13 @@ describe('SQLiteSyncStorage', () => {
 			expect(storage.getSnapshot().documents.length).toBe(3)
 		})
 
-		it('[SQ6] fresh databases start at migration version 3', () => {
+		it('[SQ6] fresh databases start at migration version 2', () => {
 			const sql = createWrapper()
 			new SQLiteSyncStorage<TLRecord>({ sql, snapshot: makeContractSnapshot(contractRecords) })
 			const row = sql
 				.prepare<{ migrationVersion: number }>('SELECT migrationVersion FROM metadata')
 				.all()[0]
-			expect(row?.migrationVersion).toBe(3)
+			expect(row?.migrationVersion).toBe(2)
 		})
 	})
 })

package/src/lib/SQLiteSyncStorage.ts

@@ -86,15 +86,9 @@ export function migrateSqliteSyncStorage(
 	storage: TLSyncSqliteWrapper,
 	{
 		documentsTable = 'documents',
-		objectsTable = 'objects',
 		tombstonesTable = 'tombstones',
 		metadataTable = 'metadata',
-	}: {
-		documentsTable?: string
-		objectsTable?: string
-		tombstonesTable?: string
-		metadataTable?: string
-	} = {}
+	}: { documentsTable?: string; tombstonesTable?: string; metadataTable?: string } = {}
 ): void {
 	let migrationVersion = 0
 	try {
@@ -150,34 +144,18 @@ export function migrateSqliteSyncStorage(
 				state BLOB NOT NULL,
 				lastChangedClock INTEGER NOT NULL
 			);
-
+			
 			INSERT INTO ${documentsTable}_new (id, state, lastChangedClock)
 			SELECT id, CAST(state AS BLOB), lastChangedClock FROM ${documentsTable};
-
+			
 			DROP TABLE ${documentsTable};
-
+			
 			ALTER TABLE ${documentsTable}_new RENAME TO ${documentsTable};
-
+			
 			CREATE INDEX idx_${documentsTable}_lastChangedClock ON ${documentsTable}(lastChangedClock);
 		`)
 	}
 
-	if (migrationVersion === 2) {
-		// Migration 3: Add the object-store lane table. Object-lane records (e.g. comments) are
-		// partitioned out of the documents table so the document snapshot never contains them.
-		// They share the documents' clock and tombstones.
-		migrationVersion++
-		storage.exec(`
-			CREATE TABLE ${objectsTable} (
-				id TEXT PRIMARY KEY,
-				state BLOB NOT NULL,
-				lastChangedClock INTEGER NOT NULL
-			);
-
-			CREATE INDEX idx_${objectsTable}_lastChangedClock ON ${objectsTable}(lastChangedClock);
-		`)
-	}
-
 	// add more migrations here if and when needed
 
 	storage.exec(`UPDATE ${metadataTable} SET migrationVersion = ${migrationVersion}`)
@@ -272,64 +250,22 @@ export class SQLiteSyncStorage<R extends UnknownRecord> implements TLSyncStorage
 
 	private readonly sql: TLSyncSqliteWrapper
 
-	/** @internal */
-	readonly objectTypes: ReadonlySet<string>
-
 	constructor({
 		sql,
 		snapshot,
-		objectTypes,
 		onChange,
 	}: {
 		sql: TLSyncSqliteWrapper
 		snapshot?: RoomSnapshot | StoreSnapshot<R>
-		/**
-		 * Record type names stored in the object-store lane. Records of these types are routed to
-		 * a separate table: excluded from `getSnapshot()`, returned by `getObjectsSnapshot()`.
-		 * They share the documents' clock, tombstones, and transactions.
-		 */
-		objectTypes?: readonly string[]
 		onChange?(arg: TLSyncStorageOnChangeCallbackProps): unknown
 	}) {
 		this.sql = sql
-		this.objectTypes = new Set(objectTypes ?? [])
 		const prefix = sql.config?.tablePrefix ?? ''
 		const documentsTable = `${prefix}documents`
-		const objectsTable = `${prefix}objects`
 		const tombstonesTable = `${prefix}tombstones`
 		const metadataTable = `${prefix}metadata`
 
-		migrateSqliteSyncStorage(this.sql, {
-			documentsTable,
-			objectsTable,
-			tombstonesTable,
-			metadataTable,
-		})
-
-		// Both record tables have identical shape; prepare the same statements for each.
-		const makeRecordTableStmts = (table: string) => ({
-			get: this.sql.prepare<{ state: Uint8Array }, [id: string]>(
-				`SELECT state FROM ${table} WHERE id = ?`
-			),
-			insert: this.sql.prepare<void, [id: string, state: Uint8Array, lastChangedClock: number]>(
-				`INSERT OR REPLACE INTO ${table} (id, state, lastChangedClock) VALUES (?, ?, ?)`
-			),
-			delete: this.sql.prepare<void, [id: string]>(`DELETE FROM ${table} WHERE id = ?`),
-			exists: this.sql.prepare<{ id: string }, [id: string]>(
-				`SELECT id FROM ${table} WHERE id = ?`
-			),
-			iterate: this.sql.prepare<{ state: Uint8Array; lastChangedClock: number }>(
-				`SELECT state, lastChangedClock FROM ${table}`
-			),
-			iterateEntries: this.sql.prepare<{ id: string; state: Uint8Array }>(
-				`SELECT id, state FROM ${table}`
-			),
-			iterateKeys: this.sql.prepare<{ id: string }>(`SELECT id FROM ${table}`),
-			iterateValues: this.sql.prepare<{ state: Uint8Array }>(`SELECT state FROM ${table}`),
-			changedSince: this.sql.prepare<{ state: Uint8Array }, [sinceClock: number]>(
-				`SELECT state FROM ${table} WHERE lastChangedClock > ?`
-			),
-		})
+		migrateSqliteSyncStorage(this.sql, { documentsTable, tombstonesTable, metadataTable })
 
 		// Prepare all statements once
 		this.stmts = {
@@ -349,9 +285,33 @@ export class SQLiteSyncStorage<R extends UnknownRecord> implements TLSyncStorage
 				`UPDATE ${metadataTable} SET documentClock = documentClock + 1`
 			),
 
-			// Record tables (document lane + object-store lane)
-			documents: makeRecordTableStmts(documentsTable),
-			objects: makeRecordTableStmts(objectsTable),
+			// Documents
+			getDocument: this.sql.prepare<{ state: Uint8Array }, [id: string]>(
+				`SELECT state FROM ${documentsTable} WHERE id = ?`
+			),
+			insertDocument: this.sql.prepare<
+				void,
+				[id: string, state: Uint8Array, lastChangedClock: number]
+			>(`INSERT OR REPLACE INTO ${documentsTable} (id, state, lastChangedClock) VALUES (?, ?, ?)`),
+			deleteDocument: this.sql.prepare<void, [id: string]>(
+				`DELETE FROM ${documentsTable} WHERE id = ?`
+			),
+			documentExists: this.sql.prepare<{ id: string }, [id: string]>(
+				`SELECT id FROM ${documentsTable} WHERE id = ?`
+			),
+			iterateDocuments: this.sql.prepare<{ state: Uint8Array; lastChangedClock: number }>(
+				`SELECT state, lastChangedClock FROM ${documentsTable}`
+			),
+			iterateDocumentEntries: this.sql.prepare<{ id: string; state: Uint8Array }>(
+				`SELECT id, state FROM ${documentsTable}`
+			),
+			iterateDocumentKeys: this.sql.prepare<{ id: string }>(`SELECT id FROM ${documentsTable}`),
+			iterateDocumentValues: this.sql.prepare<{ state: Uint8Array }>(
+				`SELECT state FROM ${documentsTable}`
+			),
+			getDocumentsChangedSince: this.sql.prepare<{ state: Uint8Array }, [sinceClock: number]>(
+				`SELECT state FROM ${documentsTable} WHERE lastChangedClock > ?`
+			),
 
 			// Tombstones
 			insertTombstone: this.sql.prepare<void, [id: string, clock: number]>(
@@ -394,17 +354,12 @@ export class SQLiteSyncStorage<R extends UnknownRecord> implements TLSyncStorage
 			// Clear existing data
 			this.sql.exec(`
 				DELETE FROM ${documentsTable};
-				DELETE FROM ${objectsTable};
 				DELETE FROM ${tombstonesTable};
 			`)
 
-			// Insert records, routing object-lane types into their partition (a seed snapshot may
-			// carry object-lane records merged in, e.g. loaded from a separate persistence lane)
+			// Insert documents
 			for (const doc of snapshot.documents) {
-				const table = this.objectTypes.has(doc.state.typeName)
-					? this.stmts.objects
-					: this.stmts.documents
-				table.insert.run(doc.state.id, encodeState(doc.state), doc.lastChangedClock)
+				this.stmts.insertDocument.run(doc.state.id, encodeState(doc.state), doc.lastChangedClock)
 			}
 
 			// Insert tombstones
@@ -420,21 +375,6 @@ export class SQLiteSyncStorage<R extends UnknownRecord> implements TLSyncStorage
 				tombstoneHistoryStartsAtClock,
 				JSON.stringify(snapshot.schema)
 			)
-		} else {
-			// One-time sweep: rooms written before the objects table existed may have object-lane
-			// records sitting in the documents table. Record ids are typeName-prefixed, so a PK
-			// range scan per object type moves them cheaply (no-op once clean).
-			for (const typeName of this.objectTypes) {
-				const lo = `${typeName}:`
-				// ';' is the next code point after ':' — [lo, hi) covers exactly the `type:` prefix
-				const hi = `${typeName};`
-				this.sql.exec(`
-					INSERT OR REPLACE INTO ${objectsTable} (id, state, lastChangedClock)
-					SELECT id, state, lastChangedClock FROM ${documentsTable}
-					WHERE id >= '${lo}' AND id < '${hi}';
-					DELETE FROM ${documentsTable} WHERE id >= '${lo}' AND id < '${hi}';
-				`)
-			}
 		}
 		if (onChange) {
 			this.onChange(onChange)
@@ -530,25 +470,16 @@ export class SQLiteSyncStorage<R extends UnknownRecord> implements TLSyncStorage
 	)
 
 	getSnapshot(): RoomSnapshot {
-		// object-lane records live in their own table, so the document snapshot is
-		// pure-document by construction
 		return {
 			tombstoneHistoryStartsAtClock: this._getTombstoneHistoryStartsAtClock(),
 			documentClock: this.getClock(),
-			documents: Array.from(this._iterateRecords(this.stmts.documents)),
+			documents: Array.from(this._iterateDocuments()),
 			tombstones: Object.fromEntries(this._iterateTombstones()),
 			schema: this._getSchema(),
 		}
 	}
-
-	getObjectsSnapshot(): RoomSnapshot['documents'] {
-		return Array.from(this._iterateRecords(this.stmts.objects))
-	}
-
-	private *_iterateRecords(
-		table: SQLiteSyncStorage<R>['stmts']['documents']
-	): IterableIterator<{ state: R; lastChangedClock: number }> {
-		for (const row of table.iterate.iterate()) {
+	private *_iterateDocuments(): IterableIterator<{ state: R; lastChangedClock: number }> {
+		for (const row of this.stmts.iterateDocuments.iterate()) {
 			yield { state: decodeState<R>(row.state), lastChangedClock: row.lastChangedClock }
 		}
 	}
@@ -600,21 +531,9 @@ class SQLiteSyncStorageTransaction<R extends UnknownRecord> implements TLSyncSto
 		return this._clock
 	}
 
-	/**
-	 * Which record table an id belongs to. Record ids are typeName-prefixed (`comment:abc`),
-	 * so the partition is derivable from the id alone.
-	 */
-	private tableFor(id: string) {
-		const sep = id.indexOf(':')
-		if (sep === -1) return this.stmts.documents
-		return this.storage.objectTypes.has(id.slice(0, sep))
-			? this.stmts.objects
-			: this.stmts.documents
-	}
-
 	get(id: string): R | undefined {
 		this.assertNotClosed()
-		const row = this.tableFor(id).get.all(id)[0]
+		const row = this.stmts.getDocument.all(id)[0]
 		if (!row) return undefined
 		return decodeState<R>(row.state)
 	}
@@ -625,54 +544,41 @@ class SQLiteSyncStorageTransaction<R extends UnknownRecord> implements TLSyncSto
 		const clock = this.getNextClock()
 		// Automatically clear tombstone if it exists
 		this.stmts.deleteTombstone.run(id)
-		// route by type: object-lane records live in their own table
-		const table = this.storage.objectTypes.has(record.typeName)
-			? this.stmts.objects
-			: this.stmts.documents
-		table.insert.run(id, encodeState(record), clock)
+		this.stmts.insertDocument.run(id, encodeState(record), clock)
 	}
 
 	delete(id: string): void {
 		this.assertNotClosed()
-		const table = this.tableFor(id)
 		// Only create a tombstone if the record actually exists
-		const exists = table.exists.all(id)[0]
+		const exists = this.stmts.documentExists.all(id)[0]
 		if (!exists) return
 		const clock = this.getNextClock()
-		table.delete.run(id)
+		this.stmts.deleteDocument.run(id)
 		this.stmts.insertTombstone.run(id, clock)
 		this.storage.pruneTombstones()
 	}
 
-	// iteration spans both record tables so schema migrations cover object-lane records too
-
 	*entries(): IterableIterator<[string, R]> {
 		this.assertNotClosed()
-		for (const table of [this.stmts.documents, this.stmts.objects]) {
-			for (const row of table.iterateEntries.iterate()) {
-				this.assertNotClosed()
-				yield [row.id, decodeState<R>(row.state)]
-			}
+		for (const row of this.stmts.iterateDocumentEntries.iterate()) {
+			this.assertNotClosed()
+			yield [row.id, decodeState<R>(row.state)]
 		}
 	}
 
 	*keys(): IterableIterator<string> {
 		this.assertNotClosed()
-		for (const table of [this.stmts.documents, this.stmts.objects]) {
-			for (const row of table.iterateKeys.iterate()) {
-				this.assertNotClosed()
-				yield row.id
-			}
+		for (const row of this.stmts.iterateDocumentKeys.iterate()) {
+			this.assertNotClosed()
+			yield row.id
 		}
 	}
 
 	*values(): IterableIterator<R> {
 		this.assertNotClosed()
-		for (const table of [this.stmts.documents, this.stmts.objects]) {
-			for (const row of table.iterateValues.iterate()) {
-				this.assertNotClosed()
-				yield decodeState<R>(row.state)
-			}
+		for (const row of this.stmts.iterateDocumentValues.iterate()) {
+			this.assertNotClosed()
+			yield decodeState<R>(row.state)
 		}
 	}
 
@@ -697,22 +603,17 @@ class SQLiteSyncStorageTransaction<R extends UnknownRecord> implements TLSyncSto
 		const diff: TLSyncForwardDiff<R> = { puts: {}, deletes: [] }
 		const wipeAll = sinceClock < this.storage._getTombstoneHistoryStartsAtClock()
 
-		// both record tables share the clock and tombstones, so the change feed spans both
 		if (wipeAll) {
-			// If wipeAll, include all records
-			for (const table of [this.stmts.documents, this.stmts.objects]) {
-				for (const row of table.iterateValues.iterate()) {
-					const state = decodeState<R>(row.state)
-					diff.puts[state.id] = state
-				}
+			// If wipeAll, include all documents
+			for (const row of this.stmts.iterateDocumentValues.iterate()) {
+				const state = decodeState<R>(row.state)
+				diff.puts[state.id] = state
 			}
 		} else {
-			// Get records changed since clock
-			for (const table of [this.stmts.documents, this.stmts.objects]) {
-				for (const row of table.changedSince.iterate(sinceClock)) {
-					const state = decodeState<R>(row.state)
-					diff.puts[state.id] = state
-				}
+			// Get documents changed since clock
+			for (const row of this.stmts.getDocumentsChangedSince.iterate(sinceClock)) {
+				const state = decodeState<R>(row.state)
+				diff.puts[state.id] = state
 			}
 			// When wipeAll, deletes are redundant (full state is in puts). Only include tombstones otherwise.
 			for (const row of this.stmts.getTombstonesChangedSince.iterate(sinceClock)) {