@tldraw/sync-core 5.3.0-canary.fceaae5e9feb → 5.3.0-internal.c5c7f1d817d0

package/src/lib/InMemorySyncStorage.ts

@@ -117,6 +117,14 @@ 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 */
@@ -133,22 +141,38 @@ 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.map((d) => [
-				d.state.id,
-				{ state: devFreeze(d.state) as R, lastChangedClock: d.lastChangedClock },
-			])
+			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)
 		)
 		const documentClock = Math.max(maxClockValue, snapshot.documentClock ?? snapshot.clock ?? 0)
 
@@ -249,6 +273,8 @@ 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(),
@@ -257,6 +283,10 @@ export class InMemorySyncStorage<R extends UnknownRecord> implements TLSyncStora
 			schema: this.schema.get(),
 		}
 	}
+
+	getObjectsSnapshot(): RoomSnapshot['documents'] {
+		return Array.from(this.objects.values())
+	}
 }
 
 /**
@@ -297,9 +327,16 @@ 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)?.state
+		return (this.storage.documents.get(id) ?? this.storage.objects.get(id))?.state
 	}
 
 	set(id: string, record: R): void {
@@ -310,7 +347,11 @@ class InMemorySyncStorageTransaction<
 		if (this.storage.tombstones.has(id)) {
 			this.storage.tombstones.delete(id)
 		}
-		this.storage.documents.set(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, {
 			state: devFreeze(record) as R,
 			lastChangedClock: clock,
 		})
@@ -319,34 +360,43 @@ class InMemorySyncStorageTransaction<
 	delete(id: string): void {
 		this.assertNotClosed()
 		// Only create a tombstone if the record actually exists
-		if (!this.storage.documents.has(id)) return
+		const map = this.mapContaining(id)
+		if (!map) return
 		const clock = this.getNextClock()
-		this.storage.documents.delete(id)
+		map.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 [id, record] of this.storage.documents.entries()) {
-			this.assertNotClosed()
-			yield [id, record.state]
+		for (const map of [this.storage.documents, this.storage.objects]) {
+			for (const [id, record] of map.entries()) {
+				this.assertNotClosed()
+				yield [id, record.state]
+			}
 		}
 	}
 
 	*keys(): IterableIterator<string> {
 		this.assertNotClosed()
-		for (const key of this.storage.documents.keys()) {
-			this.assertNotClosed()
-			yield key
+		for (const map of [this.storage.documents, this.storage.objects]) {
+			for (const key of map.keys()) {
+				this.assertNotClosed()
+				yield key
+			}
 		}
 	}
 
 	*values(): IterableIterator<R> {
 		this.assertNotClosed()
-		for (const record of this.storage.documents.values()) {
-			this.assertNotClosed()
-			yield record.state
+		for (const map of [this.storage.documents, this.storage.objects]) {
+			for (const record of map.values()) {
+				this.assertNotClosed()
+				yield record.state
+			}
 		}
 	}
 
@@ -370,10 +420,13 @@ class InMemorySyncStorageTransaction<
 		}
 		const diff: TLSyncForwardDiff<R> = { puts: {}, deletes: [] }
 		const wipeAll = sinceClock < this.storage.tombstoneHistoryStartsAtClock.get()
-		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
+		// 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
+				}
 			}
 		}
 		if (!wipeAll) {

package/src/lib/RoomSession.ts

@@ -1,5 +1,5 @@
 import { SerializedSchema, UnknownRecord } from '@tldraw/store'
-import { TLSocketServerSentDataEvent } from './protocol'
+import { TLObjectStoreAccess, TLSocketServerSentDataEvent } from './protocol'
 import { TLRoomSocket } from './TLSyncRoom'
 
 /**
@@ -78,8 +78,13 @@ 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 */
+	/** Whether this session has read-only permissions for document-lane records */
 	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,6 +38,33 @@ 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>({
@@ -227,13 +254,13 @@ describe('SQLiteSyncStorage', () => {
 			expect(storage.getSnapshot().documents.length).toBe(3)
 		})
 
-		it('[SQ6] fresh databases start at migration version 2', () => {
+		it('[SQ6] fresh databases start at migration version 3', () => {
 			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(2)
+			expect(row?.migrationVersion).toBe(3)
 		})
 	})
 })

package/src/lib/SQLiteSyncStorage.ts

@@ -86,9 +86,15 @@ export function migrateSqliteSyncStorage(
 	storage: TLSyncSqliteWrapper,
 	{
 		documentsTable = 'documents',
+		objectsTable = 'objects',
 		tombstonesTable = 'tombstones',
 		metadataTable = 'metadata',
-	}: { documentsTable?: string; tombstonesTable?: string; metadataTable?: string } = {}
+	}: {
+		documentsTable?: string
+		objectsTable?: string
+		tombstonesTable?: string
+		metadataTable?: string
+	} = {}
 ): void {
 	let migrationVersion = 0
 	try {
@@ -144,18 +150,34 @@ 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}`)
@@ -250,22 +272,64 @@ 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, tombstonesTable, metadataTable })
+		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 > ?`
+			),
+		})
 
 		// Prepare all statements once
 		this.stmts = {
@@ -285,33 +349,9 @@ export class SQLiteSyncStorage<R extends UnknownRecord> implements TLSyncStorage
 				`UPDATE ${metadataTable} SET documentClock = documentClock + 1`
 			),
 
-			// 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 > ?`
-			),
+			// Record tables (document lane + object-store lane)
+			documents: makeRecordTableStmts(documentsTable),
+			objects: makeRecordTableStmts(objectsTable),
 
 			// Tombstones
 			insertTombstone: this.sql.prepare<void, [id: string, clock: number]>(
@@ -354,12 +394,17 @@ export class SQLiteSyncStorage<R extends UnknownRecord> implements TLSyncStorage
 			// Clear existing data
 			this.sql.exec(`
 				DELETE FROM ${documentsTable};
+				DELETE FROM ${objectsTable};
 				DELETE FROM ${tombstonesTable};
 			`)
 
-			// Insert documents
+			// 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)
 			for (const doc of snapshot.documents) {
-				this.stmts.insertDocument.run(doc.state.id, encodeState(doc.state), doc.lastChangedClock)
+				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)
 			}
 
 			// Insert tombstones
@@ -375,6 +420,21 @@ 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)
@@ -470,16 +530,25 @@ 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._iterateDocuments()),
+			documents: Array.from(this._iterateRecords(this.stmts.documents)),
 			tombstones: Object.fromEntries(this._iterateTombstones()),
 			schema: this._getSchema(),
 		}
 	}
-	private *_iterateDocuments(): IterableIterator<{ state: R; lastChangedClock: number }> {
-		for (const row of this.stmts.iterateDocuments.iterate()) {
+
+	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()) {
 			yield { state: decodeState<R>(row.state), lastChangedClock: row.lastChangedClock }
 		}
 	}
@@ -531,9 +600,21 @@ 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.stmts.getDocument.all(id)[0]
+		const row = this.tableFor(id).get.all(id)[0]
 		if (!row) return undefined
 		return decodeState<R>(row.state)
 	}
@@ -544,41 +625,54 @@ class SQLiteSyncStorageTransaction<R extends UnknownRecord> implements TLSyncSto
 		const clock = this.getNextClock()
 		// Automatically clear tombstone if it exists
 		this.stmts.deleteTombstone.run(id)
-		this.stmts.insertDocument.run(id, encodeState(record), clock)
+		// 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)
 	}
 
 	delete(id: string): void {
 		this.assertNotClosed()
+		const table = this.tableFor(id)
 		// Only create a tombstone if the record actually exists
-		const exists = this.stmts.documentExists.all(id)[0]
+		const exists = table.exists.all(id)[0]
 		if (!exists) return
 		const clock = this.getNextClock()
-		this.stmts.deleteDocument.run(id)
+		table.delete.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 row of this.stmts.iterateDocumentEntries.iterate()) {
-			this.assertNotClosed()
-			yield [row.id, decodeState<R>(row.state)]
+		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)]
+			}
 		}
 	}
 
 	*keys(): IterableIterator<string> {
 		this.assertNotClosed()
-		for (const row of this.stmts.iterateDocumentKeys.iterate()) {
-			this.assertNotClosed()
-			yield row.id
+		for (const table of [this.stmts.documents, this.stmts.objects]) {
+			for (const row of table.iterateKeys.iterate()) {
+				this.assertNotClosed()
+				yield row.id
+			}
 		}
 	}
 
 	*values(): IterableIterator<R> {
 		this.assertNotClosed()
-		for (const row of this.stmts.iterateDocumentValues.iterate()) {
-			this.assertNotClosed()
-			yield decodeState<R>(row.state)
+		for (const table of [this.stmts.documents, this.stmts.objects]) {
+			for (const row of table.iterateValues.iterate()) {
+				this.assertNotClosed()
+				yield decodeState<R>(row.state)
+			}
 		}
 	}
 
@@ -603,17 +697,22 @@ 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 documents
-			for (const row of this.stmts.iterateDocumentValues.iterate()) {
-				const state = decodeState<R>(row.state)
-				diff.puts[state.id] = state
+			// 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
+				}
 			}
 		} else {
-			// 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
+			// 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
+				}
 			}
 			// When wipeAll, deletes are redundant (full state is in puts). Only include tombstones otherwise.
 			for (const row of this.stmts.getTombstonesChangedSince.iterate(sinceClock)) {