@chipmobilesdk/rn-local-db 0.3.0 → 0.5.0

package/lib/typescript/module/testing/memory-adapter/attachments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attachments.d.ts","sourceRoot":"","sources":["../../../../../src/testing/memory-adapter/attachments.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,2BAAwB,CAAC;AAe1D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAS,CAAC;AAChD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAS,CAAC;AAEpD,iFAAiF;AACjF,MAAM,WAAW,QAAQ;IACxB,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB;AAED,MAAM,WAAW,oBAAoB;IACpC,KAAK,EAAE,gBAAgB,CAAC;IACxB,OAAO,EAAE,oBAAoB,CAAC;IAC9B,GAAG,EAAE,MAAM,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,IAAI,CAAC;CACvB;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,oBAAoB,IAGzD,WAAW,QAAQ,KAAG,WAAW,CAwGzC"}

package/lib/typescript/module/testing/memory-adapter/collection.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Collection operations over the in-memory store.
+ *
+ * Every semantic decision — filtering, sorting, paging — is delegated to
+ * `query/`, the module the SQLite adapter also validates through. Anything
+ * decided here instead would be a place the two adapters could drift.
+ */
+import type { StorableRecordData } from '../../contract/record.js';
+import type { CollectionSchema } from '../../contract/schema.js';
+import type { CollectionOps } from '../../contract/transaction.js';
+import { type MemoryScopeStore } from './store.js';
+export type CollectionContext = {
+    store: MemoryScopeStore;
+    schema: CollectionSchema;
+    now: () => number;
+    assertOpen: () => void;
+};
+export declare function createMemoryCollection<T extends StorableRecordData>(context: CollectionContext): CollectionOps<T>;
+//# sourceMappingURL=collection.d.ts.map

package/lib/typescript/module/testing/memory-adapter/collection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collection.d.ts","sourceRoot":"","sources":["../../../../../src/testing/memory-adapter/collection.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,OAAO,KAAK,EAEX,kBAAkB,EAGlB,MAAM,0BAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAAuB,CAAC;AAC9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,+BAA4B,CAAC;AAShE,OAAO,EAAgD,KAAK,gBAAgB,EAAE,MAAM,YAAS,CAAC;AAE9F,MAAM,MAAM,iBAAiB,GAAG;IAC/B,KAAK,EAAE,gBAAgB,CAAC;IACxB,MAAM,EAAE,gBAAgB,CAAC;IACzB,GAAG,EAAE,MAAM,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,IAAI,CAAC;CACvB,CAAC;AASF,wBAAgB,sBAAsB,CAAC,CAAC,SAAS,kBAAkB,EAClE,OAAO,EAAE,iBAAiB,GACxB,aAAa,CAAC,CAAC,CAAC,CAyKlB"}

package/lib/typescript/module/testing/memory-adapter/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The in-memory adapter.
+ *
+ * Not a convenience: op-sqlite is native and unreachable from Jest, so this
+ * is the only way the package's own guarantees are testable in CI
+ * (research.md R8). Documented divergences are listed in the package README.
+ */
+import type { StorageAdapter } from '../../contract/adapter.js';
+export type MemoryAdapterOptions = {
+    /** Fixed clock, so timestamp assertions are deterministic. */
+    now?: () => number;
+    /**
+     * What a `sourcePath` attachment reads, as base64. There is no filesystem
+     * behind this adapter, so a test that writes attachments by path supplies
+     * the bytes here; without it such a write is refused with `STORAGE_ACCESS`.
+     */
+    readSourceFile?: (path: string) => Promise<string> | string;
+};
+export declare function createMemoryAdapter(options?: MemoryAdapterOptions): StorageAdapter;
+export { Budgets } from '../../contract/config.js';
+export { activeFaults } from '../faults.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/module/testing/memory-adapter/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/testing/memory-adapter/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAoBH,OAAO,KAAK,EAAkB,cAAc,EAAE,MAAM,2BAAwB,CAAC;AAoB7E,MAAM,MAAM,oBAAoB,GAAG;IAClC,8DAA8D;IAC9D,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB;;;;OAIG;IACH,cAAc,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;CAC5D,CAAC;AA0BF,wBAAgB,mBAAmB,CAAC,OAAO,GAAE,oBAAyB,GAAG,cAAc,CAwUtF;AAED,OAAO,EAAE,OAAO,EAAE,MAAM,0BAAuB,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,cAAW,CAAC"}

package/lib/typescript/module/testing/memory-adapter/migrations.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Migration execution for the in-memory adapter.
+ *
+ * Mirrors the on-device rules exactly, because migration behaviour is the
+ * thing consumers most need to test without a device: ordered, at most once
+ * per scope, atomic per step, and loud on failure (FR-047 to FR-057).
+ */
+import type { DatabaseConfig } from '../../contract/config.js';
+import type { MemoryScopeStore } from './store.js';
+export declare function runMigrations(store: MemoryScopeStore, config: DatabaseConfig, now: () => number): Promise<void>;
+//# sourceMappingURL=migrations.d.ts.map

package/lib/typescript/module/testing/memory-adapter/migrations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrations.d.ts","sourceRoot":"","sources":["../../../../../src/testing/memory-adapter/migrations.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAAuB,CAAC;AAK5D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAS,CAAC;AAEhD,wBAAsB,aAAa,CAClC,KAAK,EAAE,gBAAgB,EACvB,MAAM,EAAE,cAAc,EACtB,GAAG,EAAE,MAAM,MAAM,GACf,OAAO,CAAC,IAAI,CAAC,CA0Ef"}

package/lib/typescript/module/testing/memory-adapter/reset.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Test lifecycle helpers.
+ *
+ * `seedRecords` deliberately goes through the same write operations
+ * production code uses (FR-094). Seeding by poking the store directly would
+ * skip budget checks and timestamp handling, so tests would pass against data
+ * the package would have refused to store.
+ */
+import type { StorageAdapter } from '../../contract/adapter.js';
+import type { DatabaseConfig } from '../../contract/config.js';
+import type { RecordInput, StorableRecordData } from '../../contract/record.js';
+/**
+ * The conformance suite's "reach past the package" hooks, implemented for the
+ * in-memory store. On device the equivalent unlinks the file directly.
+ */
+export declare const memoryConformanceHooks: {
+    removeArtifactBehindTheScenes(scopeKey: string, attachmentId: string): Promise<void>;
+    removeReferenceBehindTheScenes(scopeKey: string, attachmentId: string): Promise<void>;
+};
+/** Return every in-memory database to a known-empty state (FR-093). */
+export declare function resetMemoryAdapter(_adapter?: StorageAdapter): Promise<void>;
+export declare function seedRecords<T extends StorableRecordData>(adapter: StorageAdapter, config: DatabaseConfig, collection: string, records: RecordInput<T>[]): Promise<void>;
+//# sourceMappingURL=reset.d.ts.map

package/lib/typescript/module/testing/memory-adapter/reset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reset.d.ts","sourceRoot":"","sources":["../../../../../src/testing/memory-adapter/reset.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,2BAAwB,CAAC;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAAuB,CAAC;AAC5D,OAAO,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,0BAAuB,CAAC;AAI7E;;;GAGG;AACH,eAAO,MAAM,sBAAsB;4CACY,MAAM,gBAAgB,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;6CAG3C,MAAM,gBAAgB,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAG3F,CAAC;AAEF,uEAAuE;AACvE,wBAAsB,kBAAkB,CAAC,QAAQ,CAAC,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAGjF;AAED,wBAAsB,WAAW,CAAC,CAAC,SAAS,kBAAkB,EAC7D,OAAO,EAAE,cAAc,EACvB,MAAM,EAAE,cAAc,EACtB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,WAAW,CAAC,CAAC,CAAC,EAAE,GACvB,OAAO,CAAC,IAAI,CAAC,CAUf"}

package/lib/typescript/module/testing/memory-adapter/store.d.ts

@@ -0,0 +1,54 @@
+/**
+ * The in-memory store behind the test adapter.
+ *
+ * Scope isolation is structural here for the same reason it is on device: one
+ * store per scope, held in a registry keyed by scope digest. A handle holds a
+ * reference to its own store and has no way to reach another (FR-011).
+ */
+import type { AttachmentReference } from '../../contract/attachment.js';
+import type { MigrationLedgerEntry } from '../../contract/migration.js';
+import type { StorableRecordData, StoredRecord } from '../../contract/record.js';
+import type { ScopeDeletionState } from '../../contract/scope.js';
+export type MemoryRow = {
+    id: string;
+    /** Serialized on write, parsed on read — the same payload-as-truth rule
+     * the SQLite adapter follows, so a mutation after write cannot leak in. */
+    payload: string;
+    createdAt?: number | undefined;
+    updatedAt?: number | undefined;
+    deletedAt?: number | null | undefined;
+};
+export type MemoryScopeStore = {
+    scopeKey: string;
+    schemaVersion: number;
+    ledger: Map<number, MigrationLedgerEntry>;
+    collections: Map<string, Map<string, MemoryRow>>;
+    attachments: Map<string, AttachmentReference>;
+    artifacts: Map<string, string>;
+    deletionState: ScopeDeletionState;
+    encrypted: boolean;
+    backupIncluded: boolean;
+};
+export type MemoryDatabase = {
+    name: string;
+    scopes: Map<string, MemoryScopeStore>;
+};
+export declare function databaseFor(name: string): MemoryDatabase;
+export declare function scopeStoreFor(name: string, scopeKey: string): MemoryScopeStore;
+export declare function existingScopeStore(name: string, scopeKey: string): MemoryScopeStore | undefined;
+export declare function dropScope(name: string, scopeKey: string): void;
+export declare function dropDatabase(name: string): void;
+/** Between tests (FR-093). */
+export declare function resetAllMemoryStores(): void;
+export declare function collectionMap(store: MemoryScopeStore, collection: string): Map<string, MemoryRow>;
+/**
+ * Deep copy through serialization on the way in and out.
+ *
+ * The same discipline as the SQLite adapter's payload column: a consumer that
+ * mutates the object it handed us must not change what is stored (FR-022),
+ * and what we hand back must not be a live reference into the store.
+ */
+export declare function encodePayload(data: StorableRecordData): string;
+export declare function decodePayload<T extends StorableRecordData>(payload: string): T;
+export declare function toStoredRecord<T extends StorableRecordData>(row: MemoryRow): StoredRecord<T>;
+//# sourceMappingURL=store.d.ts.map

package/lib/typescript/module/testing/memory-adapter/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../../../../src/testing/memory-adapter/store.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,8BAA2B,CAAC;AACrE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA0B,CAAC;AACrE,OAAO,KAAK,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,0BAAuB,CAAC;AAC9E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAsB,CAAC;AAE/D,MAAM,MAAM,SAAS,GAAG;IACvB,EAAE,EAAE,MAAM,CAAC;IACX;+EAC2E;IAC3E,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;CACtC,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC;IAC1C,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC;IACjD,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;IAC9C,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,aAAa,EAAE,kBAAkB,CAAC;IAClC,SAAS,EAAE,OAAO,CAAC;IACnB,cAAc,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;CACtC,CAAC;AAIF,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,CAOxD;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,gBAAgB,CAkB9E;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAE/F;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAE9D;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAE/C;AAED,8BAA8B;AAC9B,wBAAgB,oBAAoB,IAAI,IAAI,CAE3C;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAOjG;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,kBAAkB,GAAG,MAAM,CAE9D;AAED,wBAAgB,aAAa,CAAC,CAAC,SAAS,kBAAkB,EAAE,OAAO,EAAE,MAAM,GAAG,CAAC,CAE9E;AAED,wBAAgB,cAAc,CAAC,CAAC,SAAS,kBAAkB,EAAE,GAAG,EAAE,SAAS,GAAG,YAAY,CAAC,CAAC,CAAC,CAe5F"}

package/package.json

@@ -1,20 +1,34 @@
 {
 	"name": "@chipmobilesdk/rn-local-db",
-	"version": "0.3.0",
+	"version": "0.5.0",
 	"private": false,
 	"license": "UNLICENSED",
-	"main": "src/index.ts",
-	"types": "src/index.ts",
+	"source": "./src/index.ts",
+	"main": "./lib/commonjs/index.js",
+	"module": "./lib/module/index.js",
+	"types": "./lib/typescript/commonjs/index.d.ts",
 	"exports": {
 		".": {
-			"types": "./src/index.ts",
-			"react-native": "./src/index.ts",
-			"default": "./src/index.ts"
+			"chipmobilesdk-source": "./src/index.ts",
+			"import": {
+				"types": "./lib/typescript/module/index.d.ts",
+				"default": "./lib/module/index.js"
+			},
+			"require": {
+				"types": "./lib/typescript/commonjs/index.d.ts",
+				"default": "./lib/commonjs/index.js"
+			}
 		},
 		"./testing": {
-			"types": "./src/testing/index.ts",
-			"react-native": "./src/testing/index.ts",
-			"default": "./src/testing/index.ts"
+			"chipmobilesdk-source": "./src/testing/index.ts",
+			"import": {
+				"types": "./lib/typescript/module/testing/index.d.ts",
+				"default": "./lib/module/testing/index.js"
+			},
+			"require": {
+				"types": "./lib/typescript/commonjs/testing/index.d.ts",
+				"default": "./lib/commonjs/testing/index.js"
+			}
 		}
 	},
 	"files": [
@@ -33,22 +47,24 @@
 		"src/testing",
 		"skills",
 		"README.md",
-		"CHANGELOG.md"
+		"CHANGELOG.md",
+		"lib"
 	],
 	"sideEffects": false,
 	"scripts": {
+		"build": "bob build",
 		"typecheck": "tsc -p tsconfig.json && tsc -p tsconfig.test.json",
-		"pack:check": "npm pack --dry-run"
+		"pack:check": "npm pack --dry-run",
+		"prepack": "npm run build"
 	},
 	"dependencies": {
-		"@chipmobilesdk/rn-core": "^0.1.0"
+		"@chipmobilesdk/rn-core": "^0.2.0"
 	},
 	"peerDependencies": {
-		"@dr.pogodin/react-native-fs": ">=2.39.2",
-		"@op-engineering/op-sqlite": ">=17.1.0",
-		"react": ">=19",
+		"@dr.pogodin/react-native-fs": "^2.39.2",
+		"@op-engineering/op-sqlite": "^17.1.0",
 		"react-native": ">=0.85",
-		"react-native-quick-crypto": ">=1.0.0"
+		"react-native-quick-crypto": "^1.0.0"
 	},
 	"peerDependenciesMeta": {
 		"react-native-quick-crypto": {
@@ -58,5 +74,24 @@
 	"publishConfig": {
 		"access": "public",
 		"registry": "https://registry.npmjs.org/"
+	},
+	"react-native-builder-bob": {
+		"source": "src",
+		"output": "lib",
+		"targets": [
+			[
+				"commonjs",
+				{
+					"esm": true
+				}
+			],
+			[
+				"module",
+				{
+					"esm": true
+				}
+			],
+			"typescript"
+		]
 	}
 }

package/skills/sdk-rn-local-db/SKILL.md

@@ -41,7 +41,7 @@ section, not by deleting the database file.
 `deleteScopeData` and `deleteDatabase` are module-level and do not wait for open
 handles. **After either, open a NEW handle and rebuild everything derived from the
 old one** — repositories, providers, the screen behind a retry button. The old handle
-raises `SCOPE_DELETED` (or `CLOSED_HANDLE` if the app closed it first) on every call,
+is closed for you (its connection and handle slot are released) and raises `SCOPE_DELETED` (or `CLOSED_HANDLE` if the app closed it first) on every call,
 so a Retry wired to it can never succeed: the app stays broken until the process
 restarts. An interrupted deletion instead reports `SCOPE_DELETED` from the next
 `openDatabase` — call `deleteScopeData` again to finish it, then open.

package/src/adapter/budgets.ts

@@ -13,7 +13,6 @@
 
 import { Budgets } from '../contract/config';
 import { DiagnosticCodes } from '../contract/errors';
-import type { StorableRecordData } from '../contract/record';
 import { raise } from '../diagnostics/errors';
 import {
 	assertArtifactWithinBudget,
@@ -53,15 +52,7 @@ export function releaseHandleSlot(): void {
 	openHandles = Math.max(0, openHandles - 1);
 }
 
-export function openHandleCount(): number {
-	return openHandles;
-}
-
-/** Between tests, and after a `deleteDatabase` that invalidated every handle. */
+/** Between tests. */
 export function resetHandleSlots(): void {
 	openHandles = 0;
 }
-
-export function assertWritable(collection: string, data: StorableRecordData): void {
-	assertRecordWithinBudget(collection, data);
-}

package/src/adapter/collection.ts

@@ -27,18 +27,12 @@ import { decodeCursor } from '../query/cursor';
 import { buildPage, fetchLimitFor, resolvePageSize } from '../query/paginate';
 import { withStableTiebreaker } from '../query/sort';
 import { validateQuery } from '../query/validate';
-import { collectionTable, hasSoftDelete, hasTimestamps } from '../schema/declare';
+import { collectionTable, hasSoftDelete } from '../schema/declare';
 import type { Executor } from '../sqlite/connection';
 import type { SqlValue } from '../sqlite/native';
-import {
-	decodeRow,
-	encodePayload,
-	insertColumns,
-	projectedColumnNames,
-	projectedValues,
-	updateAssignments,
-} from '../sqlite/row-codec';
+import { decodeRow } from '../sqlite/row-codec';
 import { buildFilter, buildKeysetPredicate, buildOrderBy } from '../sqlite/sql-builder';
+import { insertStatement, updateStatement } from '../sqlite/statements';
 import { assertRecordWithinBudget } from './budgets';
 
 export type SqlCollectionContext = {
@@ -83,44 +77,35 @@ export function createSqlCollection<T extends StorableRecordData>(
 		async insert(record: RecordInput<T>): Promise<WriteOutcome> {
 			context.assertUsable();
 			throwIfFaulted('write');
-			assertRecordWithinBudget(schema.name, record.data);
+			const payload = assertRecordWithinBudget(schema.name, record.data);
 
-			// Checked rather than left to the primary-key constraint: the
-			// constraint would work, but inside a transaction the engine's
-			// error can arrive after other statements have run, and reporting
-			// the conflict before touching anything keeps the failure boring.
-			if (await rowById(record.id, true)) {
+			// One statement: a row that is already there is left untouched and
+			// reported, instead of a SELECT first and an INSERT after (LDB-08). The
+			// failure stays boring — nothing was written, and no engine error
+			// surfaces from inside a transaction.
+			const result = await context
+				.executor()
+				.execute(
+					...insertStatement(schema, record.id, record.data, context.now(), payload, 'ignore'),
+				);
+			if (result.rowsAffected === 0) {
 				raise(DiagnosticCodes.RECORD_CONFLICT, {
 					message: 'record already exists',
 					detail: { collection: schema.name, recordId: record.id },
 				});
 			}
-
-			const { columns, values } = insertColumns(schema, record.id, record.data, context.now());
-			await context
-				.executor()
-				.execute(
-					`INSERT INTO ${table} (${columns.map(name => `"${name}"`).join(', ')}) VALUES (${columns
-						.map(() => '?')
-						.join(', ')})`,
-					values,
-				);
 			return { operation: 'created', id: record.id };
 		},
 
 		async update(id, record): Promise<WriteOutcome> {
 			context.assertUsable();
 			throwIfFaulted('write');
-			assertRecordWithinBudget(schema.name, record.data);
+			const payload = assertRecordWithinBudget(schema.name, record.data);
 
-			const { columns, values } = updateAssignments(schema, record.data, context.now());
 			const result = await context
 				.executor()
 				.execute(
-					`UPDATE ${table} SET ${columns
-						.map(name => `"${name}" = ?`)
-						.join(', ')} WHERE id = ? AND ${LIVE}`,
-					[...values, id],
+					...updateStatement(schema, id, record.data, context.now(), payload, { liveOnly: true }),
 				);
 			if (result.rowsAffected === 0) {
 				// Creating the record instead would be a silent write to an id
@@ -133,47 +118,34 @@ export function createSqlCollection<T extends StorableRecordData>(
 		async upsert(record: RecordInput<T>): Promise<WriteOutcome> {
 			context.assertUsable();
 			throwIfFaulted('write');
-			assertRecordWithinBudget(schema.name, record.data);
-
-			const existed = (await rowById(record.id, true)) !== undefined;
+			const payload = assertRecordWithinBudget(schema.name, record.data);
 			const now = context.now();
 
-			if (existed) {
-				const assignments = ['payload = ?'];
-				const values: SqlValue[] = [encodePayload(record.data)];
-				if (hasTimestamps(schema)) {
-					assignments.push('updated_at = ?');
-					values.push(now);
-				}
-				if (hasSoftDelete(schema)) {
-					// An upsert over a soft-deleted record brings it back: the
-					// caller asked for this id to hold this data.
-					assignments.push('deleted_at = NULL');
-				}
-				const projected = projectedValues(schema, record.data);
-				for (const [index, name] of projectedColumnNames(schema).entries()) {
-					assignments.push(`"${name}" = ?`);
-					values.push(projected[index]!);
-				}
-				await context
+			// An upsert over a soft-deleted record brings it back: the caller
+			// asked for this id to hold this data.
+			const update = async (): Promise<boolean> => {
+				const result = await context
 					.executor()
-					.execute(`UPDATE ${table} SET ${assignments.join(', ')} WHERE id = ?`, [
-						...values,
-						record.id,
-					]);
+					.execute(
+						...updateStatement(schema, record.id, record.data, now, payload, { restore: true }),
+					);
+				return result.rowsAffected > 0;
+			};
+
+			// The update is tried first: one round-trip for a record that exists,
+			// with no SELECT before it (LDB-08).
+			if (await update()) {
 				return { operation: 'updated', id: record.id };
 			}
-
-			const { columns, values } = insertColumns(schema, record.id, record.data, now);
-			await context
+			const inserted = await context
 				.executor()
-				.execute(
-					`INSERT INTO ${table} (${columns.map(name => `"${name}"`).join(', ')}) VALUES (${columns
-						.map(() => '?')
-						.join(', ')})`,
-					values,
-				);
-			return { operation: 'created', id: record.id };
+				.execute(...insertStatement(schema, record.id, record.data, now, payload, 'ignore'));
+			if (inserted.rowsAffected > 0) {
+				return { operation: 'created', id: record.id };
+			}
+			// Another write created the row between the two statements.
+			await update();
+			return { operation: 'updated', id: record.id };
 		},
 
 		async get(id: string): Promise<StoredRecord<T>> {

package/src/adapter/deletion.ts

@@ -60,6 +60,51 @@ export function isScopeInvalidated(name: string, scopeKey: string): boolean {
 
 export function clearAllInvalidations(): void {
 	invalidated.clear();
+	openHandles.clear();
+}
+
+/**
+ * Handles open on a scope, so a deletion can take their connection away
+ * (LDB-14). Marking alone left the native connection and its handle slot held
+ * until the app closed a handle it had been told was dead: eight sign-outs
+ * later every open failed, with the unlinked file still pinned by its
+ * descriptor.
+ */
+const openHandles = new Map<string, Set<() => Promise<void>>>();
+
+/** Returns the function that takes the handle out of the registry again. */
+export function registerOpenHandle(
+	name: string,
+	scopeKey: string,
+	revoke: () => Promise<void>,
+): () => void {
+	const key = invalidationKey(name, scopeKey);
+	const handles = openHandles.get(key) ?? new Set();
+	handles.add(revoke);
+	openHandles.set(key, handles);
+	return () => {
+		handles.delete(revoke);
+		if (handles.size === 0) {
+			openHandles.delete(key);
+		}
+	};
+}
+
+/** Every handle on the scope, or on any scope of the database when none is named. */
+async function revokeHandles(name: string, scopeKey?: string): Promise<void> {
+	const prefix = `${name}:`;
+	for (const [key, handles] of [...openHandles]) {
+		const matches =
+			scopeKey === undefined ? key.startsWith(prefix) : key === invalidationKey(name, scopeKey);
+		if (!matches) {
+			continue;
+		}
+		openHandles.delete(key);
+		for (const revoke of handles) {
+			// A connection that will not close does not get to stop a deletion.
+			await revoke().catch(() => undefined);
+		}
+	}
 }
 
 /** Deleting a scope that holds nothing is success, not an error (FR-062). */
@@ -144,6 +189,8 @@ async function removeScope(config: ScopeTargetConfig): Promise<DeletionOutcome>
 			await markDeleting(catalog, scope.key);
 		}
 		markScopeInvalidated(config.name, scope.key);
+		// Before the files go: a connection still open on them pins them.
+		await revokeHandles(config.name, scope.key);
 
 		const removedArtifacts = await artifactIdsOnDisk(layout, scope.key);
 
@@ -241,6 +288,7 @@ export async function deleteDatabase(config: DatabaseTargetConfig): Promise<Dele
 	for (const scopeKey of scopeKeys) {
 		markScopeInvalidated(config.name, scopeKey);
 	}
+	await revokeHandles(config.name);
 
 	const removed = await removeIfPresent(layout.root);
 	return {