@chipmobilesdk/rn-local-db 0.2.1 → 0.4.0

package/src/migration/executor.ts

@@ -21,7 +21,7 @@
 
 import type { DatabaseConfig } from '../contract/config';
 import { DiagnosticCodes } from '../contract/errors';
-import type { MigrationContext } from '../contract/migration';
+import type { MigrationContext, SqlParameter } from '../contract/migration';
 import type { StorableRecordData } from '../contract/record';
 import type { CollectionSchema } from '../contract/schema';
 import type { CollectionOps } from '../contract/transaction';
@@ -29,7 +29,13 @@ import { raise } from '../diagnostics/errors';
 import { throwIfFaulted } from '../diagnostics/faults';
 import { createSqlCollection } from '../adapter/collection';
 import type { Connection, Executor } from '../sqlite/connection';
-import { ensureLedger, readSchemaVersion, recordAttempt, writeSchemaVersion } from './ledger';
+import {
+	ensureLedger,
+	FORMAT_VERSION,
+	readVersions,
+	recordAttempt,
+	writeSchemaVersion,
+} from './ledger';
 import { pendingMigrations, validateMigrationChain } from './validate-chain';
 
 export type MigrationRunContext = {
@@ -44,6 +50,8 @@ export type MigrationRunContext = {
 	 * still be holding something usable (FR-050).
 	 */
 	closeOnFailure(): Promise<void>;
+	/** The bookkeeping tables are known to exist, so creating them is skipped (LDB-07). */
+	ledgerReady?: boolean;
 };
 
 function migrationContextFor(context: MigrationRunContext, executor: Executor): MigrationContext {
@@ -66,8 +74,8 @@ function migrationContextFor(context: MigrationRunContext, executor: Executor):
 				message: 'a migration cannot abort its own transaction',
 			});
 		},
-		async execute(sql: string, params?: unknown[]): Promise<void> {
-			await executor.execute(sql, params as never);
+		async execute(sql: string, params?: SqlParameter[]): Promise<void> {
+			await executor.execute(sql, params);
 		},
 	};
 }
@@ -75,9 +83,22 @@ function migrationContextFor(context: MigrationRunContext, executor: Executor):
 export async function runMigrations(context: MigrationRunContext): Promise<number> {
 	const { config, connection } = context;
 	validateMigrationChain(config);
-	await ensureLedger(connection);
+	// Skipped when the open already found its bookkeeping tables in place.
+	if (context.ledgerReady !== true) {
+		await ensureLedger(connection);
+	}
+
+	const { schema: recorded, format } = await readVersions(connection);
 
-	const recorded = await readSchemaVersion(connection);
+	if (format > FORMAT_VERSION) {
+		// A file laid out by a newer release of this package. Reading it with
+		// older code is the same hazard as a schema downgrade, one layer down.
+		await context.closeOnFailure();
+		raise(DiagnosticCodes.SCHEMA_DOWNGRADE, {
+			message: 'database was written by a newer version of this package',
+			detail: { recordedVersion: format, version: FORMAT_VERSION },
+		});
+	}
 
 	if (recorded > config.schemaVersion) {
 		// Opening anyway would mean newer data read by older code, which drops

package/src/migration/ledger.ts

@@ -12,9 +12,9 @@
  * with a long half-life, sitting in a file the next crash report might carry.
  */
 
-import type { MigrationLedgerEntry, MigrationOutcome } from '../contract/migration';
+import type { MigrationOutcome } from '../contract/migration';
 import type { Executor } from '../sqlite/connection';
-import { maybeText, num, text } from '../sqlite/values';
+import { text } from '../sqlite/values';
 
 /** Physical layout version, independent of the app's schema version. */
 export const FORMAT_VERSION = 1;
@@ -44,20 +44,23 @@ export async function ensureLedger(executor: Executor): Promise<void> {
 	);
 }
 
-async function readMeta(executor: Executor, key: string): Promise<string | null> {
-	const result = await executor.execute('SELECT value FROM _meta WHERE key = ?', [key]);
-	const row = result.rows[0];
-	return row ? text(row.value) : null;
-}
-
-export async function readSchemaVersion(executor: Executor): Promise<number> {
-	const raw = await readMeta(executor, 'schema_version');
-	return raw === null ? 0 : Number(raw);
-}
+export type RecordedVersions = {
+	/** The app's schema version this scope has been migrated to. */
+	schema: number;
+	/** The physical layout this package wrote the file with. */
+	format: number;
+};
 
-export async function readFormatVersion(executor: Executor): Promise<number> {
-	const raw = await readMeta(executor, 'format_version');
-	return raw === null ? FORMAT_VERSION : Number(raw);
+/** Both versions in one read: every open asks for them. */
+export async function readVersions(executor: Executor): Promise<RecordedVersions> {
+	const result = await executor.execute(
+		"SELECT key, value FROM _meta WHERE key IN ('schema_version', 'format_version')",
+	);
+	const values = new Map(result.rows.map(row => [text(row.key), Number(text(row.value))]));
+	return {
+		schema: values.get('schema_version') ?? 0,
+		format: values.get('format_version') ?? FORMAT_VERSION,
+	};
 }
 
 export async function writeSchemaVersion(executor: Executor, version: number): Promise<void> {
@@ -81,15 +84,3 @@ export async function recordAttempt(
 		[entry.version, entry.attemptedAt, entry.outcome, entry.failureCode ?? null],
 	);
 }
-
-export async function readLedger(executor: Executor): Promise<MigrationLedgerEntry[]> {
-	const result = await executor.execute(
-		'SELECT version, attempted_at, outcome, failure_code FROM _migrations ORDER BY version ASC',
-	);
-	return result.rows.map(row => ({
-		version: num(row.version),
-		attemptedAt: num(row.attempted_at),
-		outcome: text(row.outcome) as MigrationOutcome,
-		...(maybeText(row.failure_code) === null ? {} : { failureCode: text(row.failure_code) }),
-	}));
-}

package/src/platform/backup-ios.ts

@@ -32,9 +32,10 @@ export async function ensureManagedRoot(
 	layout: StorageLayout,
 	includeInPlatformBackup: boolean,
 ): Promise<void> {
-	await fileSystem().mkdir(layout.root, {
-		NSURLIsExcludedFromBackupKey: isIos() ? !includeInPlatformBackup : undefined,
-	});
+	await fileSystem().mkdir(
+		layout.root,
+		isIos() ? { NSURLIsExcludedFromBackupKey: !includeInPlatformBackup } : {},
+	);
 }
 
 /** What the package can state about iOS, where it enforces rather than reports. */

package/src/platform/bytes.ts

@@ -21,16 +21,29 @@ const LOOKUP = (() => {
 	return table;
 })();
 
+/**
+ * Codecs Hermes and Node provide but React Native's type declarations omit.
+ * Read through this view so the package type-checks without DOM or Node types.
+ */
+interface HostCodecs {
+	atob?: (data: string) => string;
+	btoa?: (data: string) => string;
+	TextEncoder?: new () => { encode(input: string): Uint8Array };
+	TextDecoder?: new () => { decode(input: Uint8Array): string };
+}
+
+export const host = globalThis as unknown as HostCodecs;
+
 /* eslint-disable no-bitwise -- base64 is bit packing; there is no clearer way to write it. */
 
 /** Characters per `String.fromCharCode` call; large spreads overflow the stack. */
 const CHUNK = 0x8000;
 
 export function base64ToBytes(base64: string): Uint8Array {
-	if (typeof globalThis.atob === 'function') {
+	if (host.atob) {
 		let binary: string | undefined;
 		try {
-			binary = globalThis.atob(base64.replace(/-/g, '+').replace(/_/g, '/'));
+			binary = host.atob(base64.replace(/-/g, '+').replace(/_/g, '/'));
 		} catch {
 			// atob is strict where Buffer was lenient; fall through to the
 			// tolerant decoder rather than turn stray characters into a crash.
@@ -63,12 +76,12 @@ export function base64ToBytes(base64: string): Uint8Array {
 }
 
 export function bytesToBase64(bytes: Uint8Array): string {
-	if (typeof globalThis.btoa === 'function') {
+	if (host.btoa) {
 		const parts: string[] = [];
 		for (let index = 0; index < bytes.length; index += CHUNK) {
 			parts.push(String.fromCharCode(...bytes.subarray(index, index + CHUNK)));
 		}
-		return globalThis.btoa(parts.join(''));
+		return host.btoa(parts.join(''));
 	}
 	const parts: string[] = [];
 	for (let start = 0; start < bytes.length; start += CHUNK * 3) {
@@ -98,8 +111,8 @@ export function bytesToBase64(bytes: Uint8Array): string {
 
 /** UTF-8 encoding. `TextEncoder` is in Hermes and Node; the loop is the fallback. */
 export function utf8Bytes(value: string): Uint8Array {
-	if (typeof TextEncoder !== 'undefined') {
-		return new TextEncoder().encode(value);
+	if (host.TextEncoder) {
+		return new host.TextEncoder().encode(value);
 	}
 	const encoded = unescape(encodeURIComponent(value));
 	const bytes = new Uint8Array(encoded.length);
@@ -111,8 +124,8 @@ export function utf8Bytes(value: string): Uint8Array {
 
 /** UTF-8 decoding, the inverse of `utf8Bytes`. */
 export function utf8String(bytes: Uint8Array): string {
-	if (typeof TextDecoder !== 'undefined') {
-		return new TextDecoder().decode(bytes);
+	if (host.TextDecoder) {
+		return new host.TextDecoder().decode(bytes);
 	}
 	let binary = '';
 	for (const byte of bytes) {

package/src/platform/fs.ts

@@ -8,8 +8,10 @@
  * rule the ESLint config enforces.
  */
 
+import { lazyPeer } from '@chipmobilesdk/rn-core';
+
 import { DiagnosticCodes } from '../contract/errors';
-import { raise } from '../diagnostics/errors';
+import { StorageError } from '../diagnostics/errors';
 
 export type FileStat = {
 	path: string;
@@ -38,44 +40,37 @@ export type FileSystem = {
 	readFile(path: string, encoding?: string): Promise<string>;
 	/** Chunked read at an offset — what FR-107a's flat memory bound rests on. */
 	read(path: string, length: number, position: number, encoding?: string): Promise<string>;
+	/** One native call, no bytes through JS: how an unencrypted file becomes an artifact. */
+	copyFile(from: string, into: string): Promise<void>;
 	stat(path: string): Promise<FileStat>;
 	readdir(path: string): Promise<string[]>;
 	unlink(path: string): Promise<void>;
 	exists(path: string): Promise<boolean>;
 };
 
-let override: FileSystem | null = null;
-let cached: FileSystem | null = null;
+/** Loaded on first use (rn-core's lazy peer); a missing peer is `STORAGE_ACCESS`. */
+const fs = lazyPeer('@dr.pogodin/react-native-fs', () => {
+	// Inside `try`, so Metro bundles an app that leaves this optional peer out.
+	try {
+		return require('@dr.pogodin/react-native-fs') as FileSystem;
+	} catch (cause) {
+		throw cause;
+	}
+});
 
-/** Swap the peer. Tests and the demo app's in-memory mode only. */
+/** Swap the peer. Tests and the demo app's in-memory mode only; `null` restores it. */
 export function setFileSystem(module: FileSystem | null): void {
-	override = module;
-	cached = null;
+	fs.override(module ?? undefined);
 }
 
 export function fileSystem(): FileSystem {
-	if (override) {
-		return override;
-	}
-	if (!cached) {
-		try {
-			cached = require('@dr.pogodin/react-native-fs') as FileSystem;
-		} catch (error) {
-			raise(DiagnosticCodes.STORAGE_ACCESS, {
+	return fs.require(
+		(_peer, cause) =>
+			new StorageError(DiagnosticCodes.STORAGE_ACCESS, {
 				message: 'filesystem peer is not installed',
-				cause: error,
-			});
-		}
-	}
-	return cached!;
-}
-
-export async function pathExists(path: string): Promise<boolean> {
-	try {
-		return await fileSystem().exists(path);
-	} catch {
-		return false;
-	}
+				cause,
+			}),
+	);
 }
 
 /** Remove a path, treating "already gone" as success (FR-062). */

package/src/platform/location.ts

@@ -18,7 +18,6 @@ export const CATALOG_FILE = 'catalog.db';
 export const SCOPES_DIR = 'scopes';
 export const DATA_FILE = 'data.db';
 export const ARTIFACTS_DIR = 'artifacts';
-export const MARKER_FILE = '.localdb-marker';
 
 /** Normalize separators and collapse redundant segments. No `..` survives. */
 export function normalizePath(path: string): string {
@@ -46,7 +45,6 @@ export type StorageLayout = {
 	scopeDataPath(scopeKey: string): string;
 	scopeArtifactsPath(scopeKey: string): string;
 	artifactPath(scopeKey: string, attachmentId: string): string;
-	markerPath: string;
 };
 
 const SCOPE_KEY = /^[0-9a-f]{64}$/;
@@ -93,7 +91,6 @@ export function createLayout(documentDirectory: string, databaseName: string): S
 	return {
 		root,
 		catalogPath: `${root}/${CATALOG_FILE}`,
-		markerPath: `${root}/${MARKER_FILE}`,
 		scopePath,
 		scopeDataPath: scopeKey => `${scopePath(scopeKey)}/${DATA_FILE}`,
 		scopeArtifactsPath: scopeKey => `${scopePath(scopeKey)}/${ARTIFACTS_DIR}`,

package/src/query/budgets.ts

@@ -10,16 +10,42 @@ import { Budgets } from '../contract/config';
 import { DiagnosticCodes } from '../contract/errors';
 import type { StorableRecordData } from '../contract/record';
 import { raise } from '../diagnostics/errors';
-import { utf8Bytes } from '../platform/bytes';
+
+/**
+ * UTF-8 length of a string, counted rather than encoded: measuring a 256 KB
+ * record used to allocate a 256 KB byte array just to read its length.
+ */
+export function utf8Length(value: string): number {
+	let bytes = 0;
+	for (let index = 0; index < value.length; index += 1) {
+		const unit = value.charCodeAt(index);
+		if (unit < 0x80) {
+			bytes += 1;
+		} else if (unit < 0x800) {
+			bytes += 2;
+		} else if (unit >= 0xd800 && unit <= 0xdbff && index + 1 < value.length) {
+			// A surrogate pair is one four-byte code point.
+			bytes += 4;
+			index += 1;
+		} else {
+			bytes += 3;
+		}
+	}
+	return bytes;
+}
 
 /** UTF-8 byte length of the serialized payload — what actually hits disk. */
 export function serializedSize(data: StorableRecordData): number {
-	const json = JSON.stringify(data ?? {});
-	return utf8Bytes(json).length;
+	return utf8Length(JSON.stringify(data ?? {}));
 }
 
-export function assertRecordWithinBudget(collection: string, data: StorableRecordData): void {
-	const size = serializedSize(data);
+/**
+ * Checks the size budget and returns the serialized payload, so the write that
+ * follows stores this string instead of serializing the record a second time.
+ */
+export function assertRecordWithinBudget(collection: string, data: StorableRecordData): string {
+	const payload = JSON.stringify(data ?? {});
+	const size = utf8Length(payload);
 	if (size > Budgets.MAX_RECORD_BYTES) {
 		// Truncating would be silent data loss; failing opaquely would leave
 		// the consumer guessing. The size and the limit are both safe to
@@ -29,6 +55,7 @@ export function assertRecordWithinBudget(collection: string, data: StorableRecor
 			detail: { collection, sizeBytes: size, limitBytes: Budgets.MAX_RECORD_BYTES },
 		});
 	}
+	return payload;
 }
 
 export function assertBatchWithinBudget(count: number): void {

package/src/query/cursor.ts

@@ -14,7 +14,7 @@ import type { StoredRecord } from '../contract/record';
 import { raise } from '../diagnostics/errors';
 import { compareValues } from './compare';
 import { sortValueOf } from './sort';
-import { base64ToBytes, bytesToBase64, utf8Bytes, utf8String } from '../platform/bytes';
+import { base64ToBytes, bytesToBase64, host, utf8Bytes, utf8String } from '../platform/bytes';
 
 export type CursorPayload = {
 	/** Sort key fields and directions, so a cursor cannot be reused across shapes. */
@@ -28,15 +28,15 @@ function shapeOf(sort: SortKey[]): string {
 }
 
 function toBase64(value: string): string {
-	if (typeof globalThis.btoa === 'function') {
-		return globalThis.btoa(unescape(encodeURIComponent(value)));
+	if (host.btoa) {
+		return host.btoa(unescape(encodeURIComponent(value)));
 	}
 	return bytesToBase64(utf8Bytes(value));
 }
 
 function fromBase64(value: string): string {
-	if (typeof globalThis.atob === 'function') {
-		return decodeURIComponent(escape(globalThis.atob(value)));
+	if (host.atob) {
+		return decodeURIComponent(escape(host.atob(value)));
 	}
 	return utf8String(base64ToBytes(value));
 }

package/src/schema/validate-config.ts

@@ -11,6 +11,7 @@ import { Budgets, type DatabaseConfig } from '../contract/config';
 import { DiagnosticCodes } from '../contract/errors';
 import type { CollectionSchema } from '../contract/schema';
 import { raise } from '../diagnostics/errors';
+import { validateMigrationChain } from '../migration/validate-chain';
 import { validateDescriptor } from '../scope/validate';
 
 const IDENTIFIER = /^[A-Za-z][A-Za-z0-9_]{0,62}$/;
@@ -71,58 +72,6 @@ function validateCollection(collection: CollectionSchema, seen: Set<string>): vo
 	}
 }
 
-function validateMigrations(config: DatabaseConfig): void {
-	const migrations = config.migrations ?? [];
-	if (!Number.isInteger(config.schemaVersion) || config.schemaVersion < 1) {
-		raise(DiagnosticCodes.MIGRATION_CONFIG_INVALID, {
-			message: 'schemaVersion must be a positive integer',
-		});
-	}
-
-	const versions = new Set<number>();
-	for (const migration of migrations) {
-		if (!Number.isInteger(migration.version) || migration.version < 1) {
-			raise(DiagnosticCodes.MIGRATION_CONFIG_INVALID, {
-				message: 'migration version must be a positive integer',
-			});
-		}
-		if (versions.has(migration.version)) {
-			raise(DiagnosticCodes.MIGRATION_CONFIG_INVALID, {
-				message: 'duplicate migration version',
-				detail: { version: migration.version },
-			});
-		}
-		versions.add(migration.version);
-		if (typeof migration.migrate !== 'function') {
-			raise(DiagnosticCodes.MIGRATION_CONFIG_INVALID, {
-				message: 'migration has no migrate function',
-				detail: { version: migration.version },
-			});
-		}
-	}
-
-	// A chain must be able to carry a database from 1 to schemaVersion. A gap
-	// means some upgrading user has no path across it, which is worse than
-	// refusing to open.
-	for (let version = 1; version <= config.schemaVersion; version += 1) {
-		if (!versions.has(version)) {
-			raise(DiagnosticCodes.MIGRATION_CONFIG_INVALID, {
-				message: 'migration chain has a gap',
-				detail: { version },
-			});
-		}
-	}
-
-	for (const version of versions) {
-		if (version > config.schemaVersion) {
-			raise(DiagnosticCodes.MIGRATION_CONFIG_INVALID, {
-				message: 'migration version exceeds the declared schemaVersion',
-				detail: { version },
-			});
-		}
-	}
-}
-
 export function validateConfig(config: DatabaseConfig): void {
 	if (!config || typeof config !== 'object') {
 		configInvalid('database config is required');
@@ -148,7 +97,8 @@ export function validateConfig(config: DatabaseConfig): void {
 		validateCollection(collection, seen);
 	}
 
-	validateMigrations(config);
+	// The one definition of a valid chain, shared with the executor (LDB-12).
+	validateMigrationChain(config);
 
 	if (config.encryption && config.encryption.enabled) {
 		if (typeof config.encryption.keyProvider?.getKey !== 'function') {

package/src/sqlite/batch.ts

@@ -21,8 +21,7 @@ import { raise } from '../diagnostics/errors';
 import { assertBatchWithinBudget, assertRecordWithinBudget } from '../query/budgets';
 import { collectionTable, hasSoftDelete } from '../schema/declare';
 import type { Connection } from './connection';
-import type { SqlValue } from './native';
-import { insertColumns, updateAssignments } from './row-codec';
+import { insertStatement, updateStatement, type Statement } from './statements';
 
 export type BatchContext = {
 	connection: Connection;
@@ -31,42 +30,12 @@ export type BatchContext = {
 	now(): number;
 };
 
-type Command = [string, SqlValue[]];
+type Command = Statement;
 
 function quoted(schema: CollectionSchema): string {
 	return `"${collectionTable(schema.name)}"`;
 }
 
-function insertCommand(
-	schema: CollectionSchema,
-	id: string,
-	data: Parameters<typeof insertColumns>[2],
-	now: number,
-): Command {
-	const { columns, values } = insertColumns(schema, id, data, now);
-	return [
-		`INSERT INTO ${quoted(schema)} (${columns
-			.map(name => `"${name}"`)
-			.join(', ')}) VALUES (${columns.map(() => '?').join(', ')})`,
-		values,
-	];
-}
-
-function updateCommand(
-	schema: CollectionSchema,
-	id: string,
-	data: Parameters<typeof updateAssignments>[1],
-	now: number,
-	restore: boolean,
-): Command {
-	const { columns, values } = updateAssignments(schema, data, now);
-	const assignments = columns.map(name => `"${name}" = ?`);
-	if (restore && hasSoftDelete(schema)) {
-		assignments.push('deleted_at = NULL');
-	}
-	return [`UPDATE ${quoted(schema)} SET ${assignments.join(', ')} WHERE id = ?`, [...values, id]];
-}
-
 /**
  * Where a record stands, as this batch has left it so far. Three states, not
  * two: a soft-deleted row is invisible to reads but still holds its primary
@@ -104,13 +73,13 @@ async function resolveInsert(
 	operation: Extract<BatchOperation, { type: 'insert' }>,
 ): Promise<Resolved> {
 	const { schema, now } = resolver;
-	assertRecordWithinBudget(schema.name, operation.record.data);
+	const payload = assertRecordWithinBudget(schema.name, operation.record.data);
 	if ((await resolver.state(operation.record.id)) !== 'absent') {
 		conflict(schema, operation.record.id);
 	}
 	resolver.stage(operation.record.id, 'live');
 	return {
-		command: insertCommand(schema, operation.record.id, operation.record.data, now),
+		command: insertStatement(schema, operation.record.id, operation.record.data, now, payload),
 		outcome: { operation: 'created', id: operation.record.id },
 	};
 }
@@ -120,12 +89,14 @@ async function resolveUpdate(
 	operation: Extract<BatchOperation, { type: 'update' }>,
 ): Promise<Resolved> {
 	const { schema, now } = resolver;
-	assertRecordWithinBudget(schema.name, operation.data);
+	const payload = assertRecordWithinBudget(schema.name, operation.data);
 	if ((await resolver.state(operation.id)) !== 'live') {
 		missing(schema, operation.id);
 	}
 	return {
-		command: updateCommand(schema, operation.id, operation.data, now, false),
+		command: updateStatement(schema, operation.id, operation.data, now, payload, {
+			restore: false,
+		}),
 		outcome: { operation: 'updated', id: operation.id },
 	};
 }
@@ -135,13 +106,15 @@ async function resolveUpsert(
 	operation: Extract<BatchOperation, { type: 'upsert' }>,
 ): Promise<Resolved> {
 	const { schema, now } = resolver;
-	assertRecordWithinBudget(schema.name, operation.record.data);
+	const payload = assertRecordWithinBudget(schema.name, operation.record.data);
 	const present = (await resolver.state(operation.record.id)) !== 'absent';
 	resolver.stage(operation.record.id, 'live');
 	return {
 		command: present
-			? updateCommand(schema, operation.record.id, operation.record.data, now, true)
-			: insertCommand(schema, operation.record.id, operation.record.data, now),
+			? updateStatement(schema, operation.record.id, operation.record.data, now, payload, {
+					restore: true,
+				})
+			: insertStatement(schema, operation.record.id, operation.record.data, now, payload),
 		outcome: { operation: present ? 'updated' : 'created', id: operation.record.id },
 	};
 }
@@ -209,23 +182,39 @@ export async function runBatch(
 	const outcomes: WriteOutcome[] = [];
 	const overlay = new Map<string, RowState>();
 
+	// What the batch will touch, read once per collection (LDB-08). A batch of a
+	// thousand operations used to make a thousand SELECTs before its one write.
+	// The ids travel as one JSON parameter, so no variable limit applies.
+	const known = new Map<string, RowState>();
+	const idsByCollection = new Map<string, Set<string>>();
+	for (const operation of operations) {
+		const id = 'record' in operation ? operation.record.id : operation.id;
+		const ids = idsByCollection.get(operation.collection) ?? new Set<string>();
+		ids.add(id);
+		idsByCollection.set(operation.collection, ids);
+	}
+	for (const [collection, ids] of idsByCollection) {
+		const schema = context.schemaFor(collection);
+		const result = await context.connection.execute(
+			`SELECT id, deleted_at FROM ${quoted(schema)} WHERE id IN (SELECT value FROM json_each(?))`,
+			[JSON.stringify([...ids])],
+		);
+		for (const row of result.rows) {
+			known.set(
+				`${schema.name}:${String(row.id)}`,
+				row.deleted_at === null || row.deleted_at === undefined ? 'live' : 'softDeleted',
+			);
+		}
+	}
+
 	for (const operation of operations) {
 		const schema = context.schemaFor(operation.collection);
 		const resolver: Resolver = {
 			schema,
 			now: context.now(),
 			async state(id) {
-				const staged = overlay.get(`${schema.name}:${id}`);
-				if (staged !== undefined) {
-					return staged;
-				}
-				const result = await context.connection.execute(
-					`SELECT deleted_at FROM ${quoted(schema)} WHERE id = ?`,
-					[id],
-				);
-				const row = result.rows[0];
-				if (!row) return 'absent';
-				return row.deleted_at === null || row.deleted_at === undefined ? 'live' : 'softDeleted';
+				const key = `${schema.name}:${id}`;
+				return overlay.get(key) ?? known.get(key) ?? 'absent';
 			},
 			stage(id, state) {
 				overlay.set(`${schema.name}:${id}`, state);

package/src/sqlite/connection.ts

@@ -52,8 +52,6 @@ export type Connection = Executor & {
 	readonly encrypted: boolean;
 	transaction<R>(fn: (tx: TransactionExecutor) => Promise<R>): Promise<R>;
 	executeBatch(commands: [string, SqlValue[]?][]): Promise<void>;
-	/** Full-database check, for the diagnostics surface. Never run at open. */
-	integrityCheck(): Promise<boolean>;
 	close(): Promise<void>;
 };
 
@@ -180,13 +178,6 @@ export async function openConnection(options: OpenConnectionOptions): Promise<Co
 			});
 		},
 
-		async integrityCheck() {
-			assertOpen();
-			const result = await connection.execute('PRAGMA quick_check(1)');
-			const first = result.rows[0];
-			return first ? Object.values(first)[0] === 'ok' : false;
-		},
-
 		async close() {
 			if (closed) {
 				return;