@orkestrel/database 0.0.4 → 0.0.6

package/dist/src/core/index.js

@@ -52,7 +52,7 @@ var DatabaseError = class extends Error {
 		super(message);
 		this.name = "DatabaseError";
 		this.code = code;
-		this.context = context;
+		if (context !== void 0) this.context = context;
 	}
 };
 /**
@@ -90,16 +90,7 @@ function isDatabaseError(value) {
 * @returns `-1`, `0`, or `1`
 */
 function compareValues(left, right) {
-	const rankOf = (value) => {
-		if (value === void 0) return 0;
-		if (value === null) return 1;
-		if (typeof value === "boolean") return 2;
-		if (typeof value === "number") return 3;
-		if (typeof value === "string") return 4;
-		return 5;
-	};
-	const leftRank = rankOf(left);
-	const rightRank = rankOf(right);
+	const [leftRank = 5, rightRank = 5] = [left, right].map((value) => value === void 0 ? 0 : value === null ? 1 : typeof value === "boolean" ? 2 : typeof value === "number" ? 3 : typeof value === "string" ? 4 : 5);
 	if (leftRank !== rightRank) return leftRank < rightRank ? -1 : 1;
 	if (typeof left === "number" && typeof right === "number") {
 		if (Number.isNaN(left) || Number.isNaN(right)) return Number.isNaN(left) ? Number.isNaN(right) ? 0 : 1 : -1;
@@ -459,19 +450,14 @@ function shapeToColumnType(shape) {
 * ```
 */
 function isDriverMeta(value) {
-	const COLUMN_TYPES = [
+	return isRecord(value) && isFiniteNumber(value.version) && isArray(value.schema) && value.schema.every((table) => isRecord(table) && isString(table.name) && isString(table.primary) && isArray(table.columns) && table.columns.every((column) => isRecord(column) && isString(column.name) && isString(column.type) && [
 		"text",
 		"integer",
 		"real",
 		"boolean",
 		"json",
 		"blob"
-	];
-	const isColumnType = (candidate) => isString(candidate) && COLUMN_TYPES.some((type) => type === candidate);
-	const isColumnSchema = (candidate) => isRecord(candidate) && isString(candidate.name) && isColumnType(candidate.type) && isBoolean(candidate.nullable);
-	const isIndexGroup = (candidate) => isArray(candidate) && candidate.every((entry) => isString(entry));
-	const isTableSchema = (candidate) => isRecord(candidate) && isString(candidate.name) && isString(candidate.primary) && isArray(candidate.columns) && candidate.columns.every(isColumnSchema) && isArray(candidate.indexes) && candidate.indexes.every(isIndexGroup);
-	return isRecord(value) && isFiniteNumber(value.version) && isArray(value.schema) && value.schema.every(isTableSchema);
+	].some((type) => type === column.type) && isBoolean(column.nullable)) && isArray(table.indexes) && table.indexes.every((index) => isArray(index) && index.every((column) => isString(column))));
 }
 /**
 * Throw when an {@link ReadOptions.signal | AbortSignal} has fired — the shared
@@ -588,13 +574,12 @@ function planMigration(deployed, declared, from = 0, to = 1) {
 				}
 			});
 		}
-		const sameIndex = (left, right) => left.length === right.length && left.every((column, position) => column === right[position]);
-		for (const index of before.indexes) if (!table.indexes.some((candidate) => sameIndex(candidate, index))) steps.push({
+		for (const index of before.indexes) if (!table.indexes.some((candidate) => deepEqual(candidate, index))) steps.push({
 			operation: "index.remove",
 			table: table.name,
 			index
 		});
-		for (const index of table.indexes) if (!before.indexes.some((candidate) => sameIndex(candidate, index))) steps.push({
+		for (const index of table.indexes) if (!before.indexes.some((candidate) => deepEqual(candidate, index))) steps.push({
 			operation: "index.add",
 			table: table.name,
 			index
@@ -734,529 +719,674 @@ async function* driverFindings(factory) {
 		indexes: []
 	};
 	const CONFORMANCE_SCHEMA = [CONFORMANCE_USERS_SCHEMA, CONFORMANCE_POSTS_SCHEMA];
-	const findingOf = (check, message, context) => ({
-		check,
-		message,
-		context
-	});
-	const phases = [
-		{
+	try {
+		const driver = factory();
+		await driver.open(CONFORMANCE_SCHEMA);
+		await driver.close();
+	} catch (error) {
+		yield {
 			check: "open-close",
-			run: async () => {
-				const driver = factory();
-				await driver.open(CONFORMANCE_SCHEMA);
-				await driver.close();
+			message: error instanceof Error ? error.message : String(error),
+			context: { error }
+		};
+	}
+	try {
+		const driver = factory();
+		await driver.open(CONFORMANCE_SCHEMA);
+		const missing = await driver.read("users", "nope");
+		await driver.close();
+		if (missing !== void 0) yield {
+			check: "read-missing",
+			message: "read of a missing key must return undefined",
+			context: {
+				table: "users",
+				expected: void 0,
+				actual: missing
 			}
-		},
-		{
+		};
+	} catch (error) {
+		yield {
 			check: "read-missing",
-			run: async () => {
-				const driver = factory();
-				await driver.open(CONFORMANCE_SCHEMA);
-				const missing = await driver.read("users", "nope");
-				await driver.close();
-				if (missing !== void 0) return findingOf("read-missing", "read of a missing key must return undefined", {
+			message: error instanceof Error ? error.message : String(error),
+			context: { error }
+		};
+	}
+	writeRead: try {
+		const driver = factory();
+		await driver.open(CONFORMANCE_SCHEMA);
+		const input = {
+			id: "u1",
+			name: "Ada",
+			age: 30,
+			meta: { tags: ["a"] }
+		};
+		await driver.write("users", "u1", input);
+		input.name = "Mutated after write";
+		if (isRecord(input.meta) && Array.isArray(input.meta.tags)) input.meta.tags.push("mutated");
+		const stored = await driver.read("users", "u1");
+		const original = {
+			id: "u1",
+			name: "Ada",
+			age: 30,
+			meta: { tags: ["a"] }
+		};
+		if (stored === void 0 || !deepEqual(stored, original)) {
+			await driver.close();
+			yield {
+				check: "copy-in",
+				message: "write must deep-copy the input row (including nested fields) rather than store it by reference",
+				context: {
 					table: "users",
-					expected: void 0,
-					actual: missing
-				});
-			}
-		},
-		{
-			check: "write-read",
-			run: async () => {
-				const driver = factory();
-				await driver.open(CONFORMANCE_SCHEMA);
-				const input = {
-					id: "u1",
-					name: "Ada",
-					age: 30,
-					meta: { tags: ["a"] }
-				};
-				await driver.write("users", "u1", input);
-				input.name = "Mutated after write";
-				if (isRecord(input.meta) && Array.isArray(input.meta.tags)) input.meta.tags.push("mutated");
-				const stored = await driver.read("users", "u1");
-				const original = {
-					id: "u1",
-					name: "Ada",
-					age: 30,
-					meta: { tags: ["a"] }
-				};
-				if (stored === void 0 || !deepEqual(stored, original)) {
-					await driver.close();
-					return findingOf("copy-in", "write must deep-copy the input row (including nested fields) rather than store it by reference", {
-						table: "users",
-						expected: original,
-						actual: stored
-					});
+					expected: original,
+					actual: stored
 				}
-				stored.name = "Mutated after read";
-				if (isRecord(stored.meta) && Array.isArray(stored.meta.tags)) stored.meta.tags.push("mutated");
-				const reread = await driver.read("users", "u1");
-				if (reread === void 0 || !deepEqual(reread, original)) {
-					await driver.close();
-					return findingOf("copy-out", "read must deep-copy the stored row (including nested fields) rather than return it by reference", {
-						table: "users",
-						expected: original,
-						actual: reread
-					});
+			};
+			break writeRead;
+		}
+		stored.name = "Mutated after read";
+		if (isRecord(stored.meta) && Array.isArray(stored.meta.tags)) stored.meta.tags.push("mutated");
+		const reread = await driver.read("users", "u1");
+		if (reread === void 0 || !deepEqual(reread, original)) {
+			await driver.close();
+			yield {
+				check: "copy-out",
+				message: "read must deep-copy the stored row (including nested fields) rather than return it by reference",
+				context: {
+					table: "users",
+					expected: original,
+					actual: reread
 				}
-				const overwrite = {
-					id: "u1",
-					name: "Ada Overwritten",
-					age: 31
-				};
-				await driver.write("users", "u1", overwrite);
-				const overwritten = await driver.read("users", "u1");
-				await driver.close();
-				if (overwritten === void 0 || !deepEqual(overwritten, overwrite)) return findingOf("upsert", "write must upsert-overwrite an existing key", {
+			};
+			break writeRead;
+		}
+		const overwrite = {
+			id: "u1",
+			name: "Ada Overwritten",
+			age: 31
+		};
+		await driver.write("users", "u1", overwrite);
+		const overwritten = await driver.read("users", "u1");
+		await driver.close();
+		if (overwritten === void 0 || !deepEqual(overwritten, overwrite)) yield {
+			check: "upsert",
+			message: "write must upsert-overwrite an existing key",
+			context: {
+				table: "users",
+				expected: overwrite,
+				actual: overwritten
+			}
+		};
+	} catch (error) {
+		yield {
+			check: "write-read",
+			message: error instanceof Error ? error.message : String(error),
+			context: { error }
+		};
+	}
+	deletePhase: try {
+		const driver = factory();
+		await driver.open(CONFORMANCE_SCHEMA);
+		await driver.write("users", "u1", {
+			id: "u1",
+			name: "Ada",
+			age: 30
+		});
+		const first = await driver.delete("users", "u1");
+		if (first !== true) {
+			await driver.close();
+			yield {
+				check: "delete-true",
+				message: "delete of an existing key must return true",
+				context: {
 					table: "users",
-					expected: overwrite,
-					actual: overwritten
-				});
+					expected: true,
+					actual: first
+				}
+			};
+			break deletePhase;
+		}
+		const second = await driver.delete("users", "u1");
+		await driver.close();
+		if (second !== false) yield {
+			check: "delete-false",
+			message: "delete of an already-removed key must return false",
+			context: {
+				table: "users",
+				expected: false,
+				actual: second
 			}
-		},
-		{
+		};
+	} catch (error) {
+		yield {
 			check: "delete",
-			run: async () => {
-				const driver = factory();
-				await driver.open(CONFORMANCE_SCHEMA);
-				await driver.write("users", "u1", {
-					id: "u1",
-					name: "Ada",
-					age: 30
-				});
-				const first = await driver.delete("users", "u1");
-				if (first !== true) {
-					await driver.close();
-					return findingOf("delete-true", "delete of an existing key must return true", {
-						table: "users",
-						expected: true,
-						actual: first
-					});
-				}
-				const second = await driver.delete("users", "u1");
-				await driver.close();
-				if (second !== false) return findingOf("delete-false", "delete of an already-removed key must return false", {
-					table: "users",
-					expected: false,
-					actual: second
-				});
+			message: error instanceof Error ? error.message : String(error),
+			context: { error }
+		};
+	}
+	orderPhase: try {
+		const driver = factory();
+		await driver.open(CONFORMANCE_SCHEMA);
+		for (const row of [
+			{
+				id: "c",
+				name: "C",
+				age: 3
+			},
+			{
+				id: "a",
+				name: "A",
+				age: 1
+			},
+			{
+				id: "b",
+				name: "B",
+				age: 2
 			}
-		},
-		{
-			check: "order",
-			run: async () => {
-				const driver = factory();
-				await driver.open(CONFORMANCE_SCHEMA);
-				for (const row of [
-					{
-						id: "c",
-						name: "C",
-						age: 3
-					},
-					{
-						id: "a",
-						name: "A",
-						age: 1
-					},
-					{
-						id: "b",
-						name: "B",
-						age: 2
-					}
-				]) await driver.write("users", row.id, row);
-				const expected = [
-					"a",
-					"b",
-					"c"
-				];
-				const keys = [...await driver.keys("users")];
-				if (!deepEqual(keys, expected)) {
-					await driver.close();
-					return findingOf("keys-order", "keys must be returned in ascending key order", {
-						table: "users",
-						expected,
-						actual: keys
-					});
-				}
-				const scanned = [];
-				for await (const row of driver.scan("users")) scanned.push(row);
-				const scannedIds = scanned.map((row) => row.id);
-				await driver.close();
-				if (!deepEqual(scannedIds, expected)) return findingOf("scan-order", "scan must yield rows in ascending key order", {
+		]) await driver.write("users", row.id, row);
+		const expected = [
+			"a",
+			"b",
+			"c"
+		];
+		const keys = [...await driver.keys("users")];
+		if (!deepEqual(keys, expected)) {
+			await driver.close();
+			yield {
+				check: "keys-order",
+				message: "keys must be returned in ascending key order",
+				context: {
 					table: "users",
 					expected,
-					actual: scannedIds
-				});
+					actual: keys
+				}
+			};
+			break orderPhase;
+		}
+		const scanned = [];
+		for await (const row of driver.scan("users")) scanned.push(row);
+		const scannedIds = scanned.map((row) => row.id);
+		await driver.close();
+		if (!deepEqual(scannedIds, expected)) yield {
+			check: "scan-order",
+			message: "scan must yield rows in ascending key order",
+			context: {
+				table: "users",
+				expected,
+				actual: scannedIds
 			}
-		},
-		{
-			check: "clear",
-			run: async () => {
-				const driver = factory();
-				await driver.open(CONFORMANCE_SCHEMA);
-				await driver.write("users", "u1", {
-					id: "u1",
-					name: "Ada",
-					age: 30
-				});
-				await driver.write("posts", "p1", {
-					slug: "p1",
-					title: "Post"
-				});
-				await driver.clear("users");
-				const usersKeys = await driver.keys("users");
-				const postsKeys = await driver.keys("posts");
-				await driver.close();
-				if (usersKeys.length !== 0) return findingOf("clear-target", "clear must empty the targeted table", {
+		};
+	} catch (error) {
+		yield {
+			check: "order",
+			message: error instanceof Error ? error.message : String(error),
+			context: { error }
+		};
+	}
+	clearPhase: try {
+		const driver = factory();
+		await driver.open(CONFORMANCE_SCHEMA);
+		await driver.write("users", "u1", {
+			id: "u1",
+			name: "Ada",
+			age: 30
+		});
+		await driver.write("posts", "p1", {
+			slug: "p1",
+			title: "Post"
+		});
+		await driver.clear("users");
+		const usersKeys = await driver.keys("users");
+		const postsKeys = await driver.keys("posts");
+		await driver.close();
+		if (usersKeys.length !== 0) {
+			yield {
+				check: "clear-target",
+				message: "clear must empty the targeted table",
+				context: {
 					table: "users",
 					expected: [],
 					actual: usersKeys
-				});
-				if (postsKeys.length !== 1) return findingOf("clear-other", "clear must not affect other tables", {
-					table: "posts",
-					expected: 1,
-					actual: postsKeys.length
-				});
-			}
-		},
-		{
-			check: "snapshot",
-			run: async () => {
-				const driver = factory();
-				await driver.open(CONFORMANCE_SCHEMA);
-				const original = {
-					id: "u1",
-					name: "Ada",
-					age: 30
-				};
-				await driver.write("users", "u1", original);
-				const rollback = await driver.snapshot();
-				await driver.write("users", "u2", {
-					id: "u2",
-					name: "Grace",
-					age: 40
-				});
-				await driver.delete("users", "u1");
-				await rollback();
-				const keys = [...await driver.keys("users")];
-				if (!deepEqual(keys, ["u1"])) {
-					await driver.close();
-					return findingOf("snapshot-rollback", "snapshot rollback must restore the pre-snapshot key set", {
-						table: "users",
-						expected: ["u1"],
-						actual: keys
-					});
 				}
-				const restored = await driver.read("users", "u1");
-				await driver.close();
-				if (restored === void 0 || !deepEqual(restored, original)) return findingOf("snapshot-rollback-value", "snapshot rollback must restore pre-snapshot row values", {
+			};
+			break clearPhase;
+		}
+		if (postsKeys.length !== 1) yield {
+			check: "clear-other",
+			message: "clear must not affect other tables",
+			context: {
+				table: "posts",
+				expected: 1,
+				actual: postsKeys.length
+			}
+		};
+	} catch (error) {
+		yield {
+			check: "clear",
+			message: error instanceof Error ? error.message : String(error),
+			context: { error }
+		};
+	}
+	snapshotPhase: try {
+		const driver = factory();
+		await driver.open(CONFORMANCE_SCHEMA);
+		const original = {
+			id: "u1",
+			name: "Ada",
+			age: 30
+		};
+		await driver.write("users", "u1", original);
+		const rollback = await driver.snapshot();
+		await driver.write("users", "u2", {
+			id: "u2",
+			name: "Grace",
+			age: 40
+		});
+		await driver.delete("users", "u1");
+		await rollback();
+		const keys = [...await driver.keys("users")];
+		if (!deepEqual(keys, ["u1"])) {
+			await driver.close();
+			yield {
+				check: "snapshot-rollback",
+				message: "snapshot rollback must restore the pre-snapshot key set",
+				context: {
 					table: "users",
-					expected: original,
-					actual: restored
-				});
+					expected: ["u1"],
+					actual: keys
+				}
+			};
+			break snapshotPhase;
+		}
+		const restored = await driver.read("users", "u1");
+		await driver.close();
+		if (restored === void 0 || !deepEqual(restored, original)) yield {
+			check: "snapshot-rollback-value",
+			message: "snapshot rollback must restore pre-snapshot row values",
+			context: {
+				table: "users",
+				expected: original,
+				actual: restored
 			}
-		},
-		{
+		};
+	} catch (error) {
+		yield {
+			check: "snapshot",
+			message: error instanceof Error ? error.message : String(error),
+			context: { error }
+		};
+	}
+	try {
+		const driver = factory();
+		await driver.open(CONFORMANCE_SCHEMA);
+		const original = {
+			id: "u3",
+			name: "Nested",
+			age: 20,
+			meta: { tags: ["a"] }
+		};
+		await driver.write("users", "u3", original);
+		const rollback = await driver.snapshot();
+		const before = await driver.read("users", "u3");
+		if (isRecord(before) && isRecord(before.meta) && Array.isArray(before.meta.tags)) before.meta.tags.push("mutated-before-restore");
+		await driver.write("users", "u3", {
+			id: "u3",
+			name: "Nested",
+			age: 20,
+			meta: { tags: ["a", "mutated-after-write"] }
+		});
+		await rollback();
+		const restored = await driver.read("users", "u3");
+		await driver.close();
+		if (restored === void 0 || !deepEqual(restored, original)) yield {
 			check: "snapshot-nested",
-			run: async () => {
-				const driver = factory();
-				await driver.open(CONFORMANCE_SCHEMA);
-				const original = {
-					id: "u3",
-					name: "Nested",
-					age: 20,
-					meta: { tags: ["a"] }
-				};
-				await driver.write("users", "u3", original);
-				const rollback = await driver.snapshot();
-				const before = await driver.read("users", "u3");
-				if (isRecord(before) && isRecord(before.meta) && Array.isArray(before.meta.tags)) before.meta.tags.push("mutated-before-restore");
-				await driver.write("users", "u3", {
-					id: "u3",
-					name: "Nested",
-					age: 20,
-					meta: { tags: ["a", "mutated-after-write"] }
-				});
-				await rollback();
-				const restored = await driver.read("users", "u3");
-				await driver.close();
-				if (restored === void 0 || !deepEqual(restored, original)) return findingOf("snapshot-nested", "snapshot rollback must restore pre-snapshot nested field values, unaffected by a later in-place mutation of a read-back row", {
-					table: "users",
-					expected: original,
-					actual: restored
-				});
+			message: "snapshot rollback must restore pre-snapshot nested field values, unaffected by a later in-place mutation of a read-back row",
+			context: {
+				table: "users",
+				expected: original,
+				actual: restored
 			}
-		},
-		{
+		};
+	} catch (error) {
+		yield {
+			check: "snapshot-nested",
+			message: error instanceof Error ? error.message : String(error),
+			context: { error }
+		};
+	}
+	try {
+		const driver = factory();
+		await driver.open(CONFORMANCE_SCHEMA);
+		await driver.write("posts", "hello-world", {
+			slug: "hello-world",
+			title: "Hello"
+		});
+		const post = await driver.read("posts", "hello-world");
+		const key = post === void 0 ? void 0 : extractKey(post, "slug");
+		await driver.close();
+		if (key !== "hello-world") yield {
 			check: "non-id-primary",
-			run: async () => {
-				const driver = factory();
-				await driver.open(CONFORMANCE_SCHEMA);
-				await driver.write("posts", "hello-world", {
-					slug: "hello-world",
-					title: "Hello"
-				});
-				const post = await driver.read("posts", "hello-world");
-				const key = post === void 0 ? void 0 : extractKey(post, "slug");
-				await driver.close();
-				if (key !== "hello-world") return findingOf("non-id-primary", "a non-id primary key column must round-trip through the store", {
-					table: "posts",
-					expected: "hello-world",
-					actual: key
-				});
+			message: "a non-id primary key column must round-trip through the store",
+			context: {
+				table: "posts",
+				expected: "hello-world",
+				actual: key
+			}
+		};
+	} catch (error) {
+		yield {
+			check: "non-id-primary",
+			message: error instanceof Error ? error.message : String(error),
+			context: { error }
+		};
+	}
+	try {
+		const driver = factory();
+		await driver.open(CONFORMANCE_SCHEMA);
+		const nested = {
+			id: "u3",
+			name: "Nested",
+			age: 20,
+			meta: {
+				tags: ["a", "b"],
+				deep: { flag: true }
 			}
-		},
-		{
+		};
+		await driver.write("users", "u3", nested);
+		const readBack = await driver.read("users", "u3");
+		await driver.close();
+		if (readBack === void 0 || !deepEqual(readBack, nested)) yield {
 			check: "nested-roundtrip",
-			run: async () => {
-				const driver = factory();
-				await driver.open(CONFORMANCE_SCHEMA);
-				const nested = {
-					id: "u3",
-					name: "Nested",
-					age: 20,
-					meta: {
-						tags: ["a", "b"],
-						deep: { flag: true }
-					}
-				};
-				await driver.write("users", "u3", nested);
-				const readBack = await driver.read("users", "u3");
-				await driver.close();
-				if (readBack === void 0 || !deepEqual(readBack, nested)) return findingOf("nested-roundtrip", "a nested-object row must round-trip structurally", {
+			message: "a nested-object row must round-trip structurally",
+			context: {
+				table: "users",
+				expected: nested,
+				actual: readBack
+			}
+		};
+	} catch (error) {
+		yield {
+			check: "nested-roundtrip",
+			message: error instanceof Error ? error.message : String(error),
+			context: { error }
+		};
+	}
+	migratePhase: try {
+		const driver = factory();
+		if (driver.migrate === void 0) break migratePhase;
+		const deployedUsers = {
+			...CONFORMANCE_USERS_SCHEMA,
+			columns: [...CONFORMANCE_USERS_SCHEMA.columns, {
+				name: "legacy",
+				type: "boolean",
+				nullable: true
+			}]
+		};
+		await driver.open([deployedUsers, CONFORMANCE_POSTS_SCHEMA]);
+		await driver.write("users", "u1", {
+			id: "u1",
+			name: "Ada",
+			age: 30,
+			legacy: true
+		});
+		const removePlan = planMigration([deployedUsers], [CONFORMANCE_USERS_SCHEMA]);
+		await driver.migrate(removePlan);
+		const migrated = await driver.read("users", "u1");
+		if (migrated === void 0 || "legacy" in migrated) {
+			await driver.close();
+			yield {
+				check: "migrate-column-remove",
+				message: "a column.remove migration must strip the column from stored rows",
+				context: {
 					table: "users",
-					expected: nested,
-					actual: readBack
-				});
+					expected: void 0,
+					actual: migrated === void 0 ? void 0 : migrated.legacy
+				}
+			};
+			break migratePhase;
+		}
+		let caught;
+		try {
+			await driver.migrate({
+				from: 0,
+				to: 1,
+				steps: [{
+					operation: "table.remove",
+					table: "ghost"
+				}]
+			});
+		} catch (error) {
+			caught = error;
+		}
+		await driver.close();
+		if (!isDatabaseError(caught) || caught.code !== "MIGRATION") yield {
+			check: "migrate-unknown-table",
+			message: "a migration step referencing an unknown table must throw a MIGRATION DatabaseError",
+			context: {
+				table: "ghost",
+				expected: "MIGRATION",
+				actual: isDatabaseError(caught) ? caught.code : caught
 			}
-		},
-		{
+		};
+	} catch (error) {
+		yield {
 			check: "migrate",
-			run: async () => {
-				const driver = factory();
-				if (driver.migrate === void 0) return void 0;
-				const deployedUsers = {
-					...CONFORMANCE_USERS_SCHEMA,
-					columns: [...CONFORMANCE_USERS_SCHEMA.columns, {
-						name: "legacy",
-						type: "boolean",
-						nullable: true
-					}]
-				};
-				await driver.open([deployedUsers, CONFORMANCE_POSTS_SCHEMA]);
-				await driver.write("users", "u1", {
-					id: "u1",
-					name: "Ada",
-					age: 30,
-					legacy: true
-				});
-				const removePlan = planMigration([deployedUsers], [CONFORMANCE_USERS_SCHEMA]);
-				await driver.migrate(removePlan);
-				const migrated = await driver.read("users", "u1");
-				if (migrated === void 0 || "legacy" in migrated) {
-					await driver.close();
-					return findingOf("migrate-column-remove", "a column.remove migration must strip the column from stored rows", {
-						table: "users",
-						expected: void 0,
-						actual: migrated === void 0 ? void 0 : migrated.legacy
-					});
-				}
-				let caught;
-				try {
-					await driver.migrate({
-						from: 0,
-						to: 1,
-						steps: [{
-							operation: "table.remove",
-							table: "ghost"
-						}]
-					});
-				} catch (error) {
-					caught = error;
+			message: error instanceof Error ? error.message : String(error),
+			context: { error }
+		};
+	}
+	streamPhase: try {
+		const driver = factory();
+		if (driver.stream === void 0) break streamPhase;
+		await driver.open(CONFORMANCE_SCHEMA);
+		for (const row of [
+			{
+				id: "a",
+				name: "A",
+				age: 10
+			},
+			{
+				id: "b",
+				name: "B",
+				age: 20
+			},
+			{
+				id: "c",
+				name: "C",
+				age: 30
+			}
+		]) await driver.write("users", row.id, row);
+		const criteria = { conditions: [{
+			column: "age",
+			operator: "above",
+			values: [10],
+			connector: "and"
+		}] };
+		const matched = [];
+		for await (const row of driver.stream("users", criteria)) matched.push(row);
+		const matchedIds = matched.map((row) => row.id).sort();
+		if (!deepEqual(matchedIds, ["b", "c"])) {
+			await driver.close();
+			yield {
+				check: "stream-match",
+				message: "stream must yield only condition-matching rows",
+				context: {
+					table: "users",
+					expected: ["b", "c"],
+					actual: matchedIds
 				}
-				await driver.close();
-				if (!isDatabaseError(caught) || caught.code !== "MIGRATION") return findingOf("migrate-unknown-table", "a migration step referencing an unknown table must throw a MIGRATION DatabaseError", {
-					table: "ghost",
-					expected: "MIGRATION",
-					actual: isDatabaseError(caught) ? caught.code : caught
-				});
+			};
+			break streamPhase;
+		}
+		const paged = [];
+		for await (const row of driver.stream("users", {
+			offset: 1,
+			limit: 1
+		})) paged.push(row);
+		await driver.close();
+		if (paged.length !== 1) yield {
+			check: "stream-page",
+			message: "stream must honor offset and limit",
+			context: {
+				table: "users",
+				expected: 1,
+				actual: paged.length
 			}
-		},
-		{
+		};
+	} catch (error) {
+		yield {
 			check: "stream",
-			run: async () => {
-				const driver = factory();
-				if (driver.stream === void 0) return void 0;
-				await driver.open(CONFORMANCE_SCHEMA);
-				for (const row of [
-					{
-						id: "a",
-						name: "A",
-						age: 10
-					},
-					{
-						id: "b",
-						name: "B",
-						age: 20
-					},
-					{
-						id: "c",
-						name: "C",
-						age: 30
-					}
-				]) await driver.write("users", row.id, row);
-				const criteria = { conditions: [{
-					column: "age",
-					operator: "above",
-					values: [10],
-					connector: "and"
-				}] };
-				const matched = [];
-				for await (const row of driver.stream("users", criteria)) matched.push(row);
-				const matchedIds = matched.map((row) => row.id).sort();
-				if (!deepEqual(matchedIds, ["b", "c"])) {
-					await driver.close();
-					return findingOf("stream-match", "stream must yield only condition-matching rows", {
-						table: "users",
-						expected: ["b", "c"],
-						actual: matchedIds
-					});
-				}
-				const paged = [];
-				for await (const row of driver.stream("users", {
-					offset: 1,
-					limit: 1
-				})) paged.push(row);
-				await driver.close();
-				if (paged.length !== 1) return findingOf("stream-page", "stream must honor offset and limit", {
+			message: error instanceof Error ? error.message : String(error),
+			context: { error }
+		};
+	}
+	transactionPhase: try {
+		const driver = factory();
+		if (driver.transaction === void 0) break transactionPhase;
+		await driver.open(CONFORMANCE_SCHEMA);
+		await driver.write("users", "u1", {
+			id: "u1",
+			name: "Ada",
+			age: 30
+		});
+		const committing = await driver.transaction();
+		await driver.write("users", "u2", {
+			id: "u2",
+			name: "Grace",
+			age: 40
+		});
+		await committing.commit();
+		const afterCommit = [...await driver.keys("users")].sort();
+		if (!deepEqual(afterCommit, ["u1", "u2"])) {
+			await driver.close();
+			yield {
+				check: "transaction-commit",
+				message: "transaction commit must persist writes made during the scope",
+				context: {
 					table: "users",
-					expected: 1,
-					actual: paged.length
-				});
+					expected: ["u1", "u2"],
+					actual: afterCommit
+				}
+			};
+			break transactionPhase;
+		}
+		const rollingBack = await driver.transaction();
+		await driver.write("users", "u3", {
+			id: "u3",
+			name: "Marie",
+			age: 50
+		});
+		await rollingBack.rollback();
+		const afterRollback = [...await driver.keys("users")].sort();
+		await driver.close();
+		if (!deepEqual(afterRollback, ["u1", "u2"])) yield {
+			check: "transaction-rollback",
+			message: "transaction rollback must restore pre-transaction state",
+			context: {
+				table: "users",
+				expected: ["u1", "u2"],
+				actual: afterRollback
 			}
-		},
-		{
+		};
+	} catch (error) {
+		yield {
 			check: "transaction",
-			run: async () => {
-				const driver = factory();
-				if (driver.transaction === void 0) return void 0;
-				await driver.open(CONFORMANCE_SCHEMA);
-				await driver.write("users", "u1", {
-					id: "u1",
-					name: "Ada",
-					age: 30
-				});
-				const committing = await driver.transaction();
-				await driver.write("users", "u2", {
-					id: "u2",
-					name: "Grace",
-					age: 40
-				});
-				await committing.commit();
-				const afterCommit = [...await driver.keys("users")].sort();
-				if (!deepEqual(afterCommit, ["u1", "u2"])) {
-					await driver.close();
-					return findingOf("transaction-commit", "transaction commit must persist writes made during the scope", {
-						table: "users",
-						expected: ["u1", "u2"],
-						actual: afterCommit
-					});
+			message: error instanceof Error ? error.message : String(error),
+			context: { error }
+		};
+	}
+	metaPhase: try {
+		const driver = factory();
+		if (driver.meta === void 0 || driver.stamp === void 0) break metaPhase;
+		await driver.open(CONFORMANCE_SCHEMA);
+		const fresh = await driver.meta();
+		if (fresh !== void 0) {
+			await driver.close();
+			yield {
+				check: "meta-fresh",
+				message: "a fresh store must report undefined meta",
+				context: {
+					expected: void 0,
+					actual: fresh
 				}
-				const rollingBack = await driver.transaction();
-				await driver.write("users", "u3", {
-					id: "u3",
-					name: "Marie",
-					age: 50
-				});
-				await rollingBack.rollback();
-				const afterRollback = [...await driver.keys("users")].sort();
-				await driver.close();
-				if (!deepEqual(afterRollback, ["u1", "u2"])) return findingOf("transaction-rollback", "transaction rollback must restore pre-transaction state", {
-					table: "users",
-					expected: ["u1", "u2"],
-					actual: afterRollback
-				});
-			}
-		},
-		{
+			};
+			break metaPhase;
+		}
+		const stamped = {
+			version: 1,
+			schema: CONFORMANCE_SCHEMA
+		};
+		await driver.stamp(stamped);
+		const read = await driver.meta();
+		await driver.close();
+		if (read === void 0 || !deepEqual(read, stamped)) yield {
 			check: "meta-stamp",
-			run: async () => {
-				const driver = factory();
-				if (driver.meta === void 0 || driver.stamp === void 0) return void 0;
-				await driver.open(CONFORMANCE_SCHEMA);
-				const fresh = await driver.meta();
-				if (fresh !== void 0) {
-					await driver.close();
-					return findingOf("meta-fresh", "a fresh store must report undefined meta", {
-						expected: void 0,
-						actual: fresh
-					});
-				}
-				const stamped = {
-					version: 1,
-					schema: CONFORMANCE_SCHEMA
-				};
-				await driver.stamp(stamped);
-				const read = await driver.meta();
-				await driver.close();
-				if (read === void 0 || !deepEqual(read, stamped)) return findingOf("meta-stamp", "meta() must return exactly the last-stamped value", {
-					expected: stamped,
-					actual: read
-				});
+			message: "meta() must return exactly the last-stamped value",
+			context: {
+				expected: stamped,
+				actual: read
 			}
-		},
-		{
-			check: "snapshot-scoped",
-			run: async () => {
-				const driver = factory();
-				await driver.open(CONFORMANCE_SCHEMA);
-				await driver.write("users", "u1", {
-					id: "u1",
-					name: "Ada",
-					age: 30
-				});
-				await driver.write("posts", "p1", {
-					slug: "p1",
-					title: "Post"
-				});
-				const rollback = await driver.snapshot(["users"]);
-				await driver.write("users", "u2", {
-					id: "u2",
-					name: "Grace",
-					age: 40
-				});
-				await driver.write("posts", "p2", {
-					slug: "p2",
-					title: "Another post"
-				});
-				await rollback();
-				const usersKeys = [...await driver.keys("users")];
-				if (!deepEqual(usersKeys, ["u1"])) {
-					await driver.close();
-					return findingOf("snapshot-scoped-users", "a scoped snapshot must roll back only the named table", {
-						table: "users",
-						expected: ["u1"],
-						actual: usersKeys
-					});
+		};
+	} catch (error) {
+		yield {
+			check: "meta-stamp",
+			message: error instanceof Error ? error.message : String(error),
+			context: { error }
+		};
+	}
+	scopedPhase: try {
+		const driver = factory();
+		await driver.open(CONFORMANCE_SCHEMA);
+		await driver.write("users", "u1", {
+			id: "u1",
+			name: "Ada",
+			age: 30
+		});
+		await driver.write("posts", "p1", {
+			slug: "p1",
+			title: "Post"
+		});
+		const rollback = await driver.snapshot(["users"]);
+		await driver.write("users", "u2", {
+			id: "u2",
+			name: "Grace",
+			age: 40
+		});
+		await driver.write("posts", "p2", {
+			slug: "p2",
+			title: "Another post"
+		});
+		await rollback();
+		const usersKeys = [...await driver.keys("users")];
+		if (!deepEqual(usersKeys, ["u1"])) {
+			await driver.close();
+			yield {
+				check: "snapshot-scoped-users",
+				message: "a scoped snapshot must roll back only the named table",
+				context: {
+					table: "users",
+					expected: ["u1"],
+					actual: usersKeys
 				}
-				const postsKeys = [...await driver.keys("posts")].sort();
-				await driver.close();
-				if (!deepEqual(postsKeys, ["p1", "p2"])) return findingOf("snapshot-scoped-posts", "a scoped snapshot must leave an unnamed table's mutations intact", {
-					table: "posts",
-					expected: ["p1", "p2"],
-					actual: postsKeys
-				});
-			}
+			};
+			break scopedPhase;
 		}
-	];
-	for (const phase of phases) try {
-		const finding = await phase.run();
-		if (finding !== void 0) yield finding;
+		const postsKeys = [...await driver.keys("posts")].sort();
+		await driver.close();
+		if (!deepEqual(postsKeys, ["p1", "p2"])) yield {
+			check: "snapshot-scoped-posts",
+			message: "a scoped snapshot must leave an unnamed table's mutations intact",
+			context: {
+				table: "posts",
+				expected: ["p1", "p2"],
+				actual: postsKeys
+			}
+		};
 	} catch (error) {
-		yield findingOf(phase.check, error instanceof Error ? error.message : String(error), { error });
+		yield {
+			check: "snapshot-scoped",
+			message: error instanceof Error ? error.message : String(error),
+			context: { error }
+		};
 	}
 }
 /**
@@ -1343,10 +1473,12 @@ async function auditDriver(factory) {
 * ```
 */
 function generateUUID(random = Math.random) {
-	const bytes = Array.from({ length: 16 }, () => Math.floor(random() * 256) & 255);
-	bytes[6] = bytes[6] & 15 | 64;
-	bytes[8] = bytes[8] & 63 | 128;
-	const hex = bytes.map((byte) => byte.toString(16).padStart(2, "0"));
+	const hex = Array.from({ length: 16 }, (_, index) => {
+		const byte = Math.floor(random() * 256) & 255;
+		if (index === 6) return byte & 15 | 64;
+		if (index === 8) return byte & 63 | 128;
+		return byte;
+	}).map((byte) => byte.toString(16).padStart(2, "0"));
 	return `${hex.slice(0, 4).join("")}-${hex.slice(4, 6).join("")}-${hex.slice(6, 8).join("")}-${hex.slice(8, 10).join("")}-${hex.slice(10).join("")}`;
 }
 //#endregion
@@ -1383,7 +1515,12 @@ var Cursor = class {
 		if (this.#closed) return;
 		this.#index += 1;
 		while (this.#index < this.#keys.length) {
-			const row = await this.#table.get(this.#keys[this.#index]);
+			const key = this.#keys[this.#index];
+			if (key === void 0) {
+				this.#index += 1;
+				continue;
+			}
+			const row = await this.#table.get(key);
 			if (row !== void 0) {
 				this.#value = row;
 				return;
@@ -1395,12 +1532,15 @@ var Cursor = class {
 	async update(changes) {
 		if (this.#closed || this.#value === void 0) return;
 		const key = this.#keys[this.#index];
+		if (key === void 0) return;
 		await this.#table.update(key, changes);
 		this.#value = await this.#table.get(key);
 	}
 	async remove() {
 		if (this.#closed || this.#value === void 0) return;
-		await this.#table.remove(this.#keys[this.#index]);
+		const key = this.#keys[this.#index];
+		if (key === void 0) return;
+		await this.#table.remove(key);
 		this.#value = void 0;
 	}
 	close() {
@@ -1544,8 +1684,8 @@ var Query = class {
 		if (this.#filters.length === 0) return this.#table.records({
 			conditions: this.#conditions,
 			order: this.#orders,
-			limit: this.#limit,
-			offset: this.#offset
+			...this.#limit !== void 0 ? { limit: this.#limit } : {},
+			...this.#offset !== void 0 ? { offset: this.#offset } : {}
 		});
 		const fetched = await this.#table.records({
 			conditions: this.#conditions,
@@ -1578,8 +1718,8 @@ var Query = class {
 		if (this.#filters.length === 0) {
 			yield* this.#table.scan({
 				conditions: this.#conditions,
-				limit: this.#limit,
-				offset: this.#offset
+				...this.#limit !== void 0 ? { limit: this.#limit } : {},
+				...this.#offset !== void 0 ? { offset: this.#offset } : {}
 			}, options);
 			return;
 		}
@@ -1677,8 +1817,8 @@ var Table = class {
 		this.#guard = contract.is;
 		this.#generate = generate;
 		this.#emitter = new Emitter({
-			on,
-			error
+			...on !== void 0 ? { on } : {},
+			...error !== void 0 ? { error } : {}
 		});
 	}
 	get emitter() {
@@ -1984,8 +2124,8 @@ var Database = class Database {
 		this.#generate = options.key;
 		this.#version = options.version;
 		this.#emitter = new Emitter({
-			on: options.on,
-			error: options.error
+			...options.on !== void 0 ? { on: options.on } : {},
+			...options.error !== void 0 ? { error: options.error } : {}
 		});
 	}
 	get emitter() {
@@ -1999,7 +2139,8 @@ var Database = class Database {
 	}
 	table(name) {
 		if (this.#status === "closed") throw new DatabaseError("CLOSED", `Database '${this.#name}' is closed`, { name: this.#name });
-		return this.#build(name, this.#key(name), createContract(objectShape(this.#tables[name])));
+		const columns = this.#columns(name);
+		return this.#build(name, this.#key(name), createContract(objectShape(columns)));
 	}
 	import(tables, keys) {
 		return this.#spawn(tables, {
@@ -2010,7 +2151,7 @@ var Database = class Database {
 	export() {
 		const result = {};
 		for (const name of Object.keys(this.#tables)) {
-			const columns = this.#tables[name];
+			const columns = this.#columns(name);
 			result[name] = {
 				key: this.#key(name),
 				columns,
@@ -2116,14 +2257,18 @@ var Database = class Database {
 	#key(name) {
 		return this.#keys[name] ?? "id";
 	}
+	#columns(name) {
+		const columns = this.#tables[name];
+		if (columns === void 0) throw new DatabaseError("NOT_FOUND", `Table '${name}' is not declared`, { table: name });
+		return columns;
+	}
 	#schema() {
 		return Object.keys(this.#tables).map((name) => {
-			const columns = this.#tables[name];
+			const columns = this.#columns(name);
 			return {
 				name,
 				primary: this.#key(name),
-				columns: Object.keys(columns).map((column) => {
-					const shape = columns[column];
+				columns: Object.entries(columns).map(([column, shape]) => {
 					return {
 						name: column,
 						type: shapeToColumnType(shape),
@@ -2379,7 +2524,14 @@ var MemoryDriver = class {
 				const store = this.#require(step.table);
 				const rows = [...store.entries()];
 				const migrated = migrateRows(rows.map(([, row]) => row), [step]);
-				rows.forEach(([key], index) => store.set(key, migrated[index]));
+				for (const [index, [key]] of rows.entries()) {
+					const row = migrated[index];
+					if (row === void 0) throw new DatabaseError("MIGRATION", "migrate: transformed row is missing", {
+						table: step.table,
+						index
+					});
+					store.set(key, row);
+				}
 				break;
 			}
 			case "index.add":