@mvd/memrel 0.0.0-stage → 0.0.0

package/dist/index.js

@@ -0,0 +1,852 @@
+// src/errors.ts
+/** Every error memrel throws on purpose is a `MemrelError`. */
+var MemrelError = class extends Error {
+	name = "MemrelError";
+	code;
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+	}
+};
+// src/encode.ts
+/**
+* Key encoding.
+*
+* Every index is a `Map` keyed by an encoded tuple of field values. The encoding keeps value
+* types apart, so `1` and `'1'` never collide, and the same encoder is used for primary keys,
+* unique keys, foreign keys and secondary indexes. That is what lets a child's foreign key tuple
+* be used directly as a lookup into its target's index.
+*/
+const objectIds = /* @__PURE__ */ new WeakMap();
+const symbolIds = /* @__PURE__ */ new Map();
+let nextObjectId = 0;
+/** Encodes one value. Objects other than dates compare by identity. */
+function encodeValue(value) {
+	switch (typeof value) {
+		case "string": return `s:${value}`;
+		case "number": return `n:${value}`;
+		case "boolean": return value ? "b:1" : "b:0";
+		case "bigint": return `i:${value}`;
+		case "undefined": return "u";
+		case "symbol": {
+			let id = symbolIds.get(value);
+			if (id === void 0) {
+				id = nextObjectId++;
+				symbolIds.set(value, id);
+			}
+			return `y:${id}`;
+		}
+		default: {
+			if (value === null) return "z";
+			if (value instanceof Date) return `d:${value.getTime()}`;
+			let id = objectIds.get(value);
+			if (id === void 0) {
+				id = nextObjectId++;
+				objectIds.set(value, id);
+			}
+			return `o:${id}`;
+		}
+	}
+}
+/** Encodes the values of `fields` in `row`, in order. */
+function encodeFields(row, fields) {
+	const r = row;
+	if (fields.length === 1) return encodeValue(r[fields[0]]);
+	let out = "[";
+	for (let i = 0; i < fields.length; i++) {
+		if (i > 0) out += ",";
+		out += JSON.stringify(encodeValue(r[fields[i]]));
+	}
+	return `${out}]`;
+}
+/** Readable form of a row's key, for error messages: `["u1"]`, `[1,"u1"]`. */
+function displayKey(row, fields) {
+	const r = row;
+	return `[${fields.map((f) => displayValue(r[f])).join(",")}]`;
+}
+function displayValue(value) {
+	if (typeof value === "bigint") return `${value}n`;
+	if (typeof value === "symbol") return value.toString();
+	if (value instanceof Date) return value.toISOString();
+	if (value === void 0) return "undefined";
+	try {
+		const json = JSON.stringify(value);
+		if (json !== void 0) return json;
+	} catch {}
+	return Object.prototype.toString.call(value);
+}
+// src/model.ts
+/**
+* The runtime model built from a config: one {@link Table} per collection, with its refs, the
+* refs pointing at it, and its mutable index state. The config is validated here, once, when
+* the database is created.
+*/
+const ACTIONS = [
+	"cascade",
+	"restrict",
+	"setNull"
+];
+const COLLECTION_OPTIONS = /* @__PURE__ */ new Set([
+	"key",
+	"unique",
+	"indexes",
+	"refs"
+]);
+const REF_OPTIONS = /* @__PURE__ */ new Set([
+	"fields",
+	"to",
+	"references",
+	"onDelete",
+	"onUpdate",
+	"setNullFields",
+	"inverse"
+]);
+/** Names used by database-wide methods, which collections can't take. */
+const RESERVED_NAMES = /* @__PURE__ */ new Set([
+	"load",
+	"remove",
+	"transaction",
+	"snapshot",
+	"restore"
+]);
+function fail(message) {
+	throw new MemrelError("INVALID_SCHEMA", message);
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function fieldList(value, where) {
+	if (!Array.isArray(value) || value.length === 0) fail(`${where} must be a non-empty array of field names`);
+	for (const f of value) if (typeof f !== "string") fail(`${where} must only contain field names`);
+	if (new Set(value).size !== value.length) fail(`${where} contains a field twice`);
+	return [...value];
+}
+function sameList(a, b) {
+	return a.length === b.length && a.every((f, i) => f === b[i]);
+}
+function sameSet(a, b) {
+	return a.length === b.length && a.every((f) => b.includes(f));
+}
+/** Creates empty state for a table. */
+function emptyState(table) {
+	return {
+		rows: /* @__PURE__ */ new Map(),
+		uniques: table.uniques.map(() => /* @__PURE__ */ new Map()),
+		indexes: table.indexes.map(() => /* @__PURE__ */ new Map()),
+		reverse: table.refs.map(() => /* @__PURE__ */ new Map()),
+		seq: 0
+	};
+}
+/** Validates a config and builds the runtime model. */
+function buildModel(config) {
+	if (!isRecord(config)) fail("config must be an object of collections");
+	const tables = /* @__PURE__ */ new Map();
+	for (const [name, raw] of Object.entries(config)) {
+		if (RESERVED_NAMES.has(name)) fail(`'${name}' is reserved and can't be a collection name`);
+		if (!isRecord(raw)) fail(`${name}: config must be an object`);
+		for (const option of Object.keys(raw)) if (!COLLECTION_OPTIONS.has(option)) fail(`${name}: unknown option '${option}'`);
+		const key = fieldList(raw.key, `${name}.key`);
+		const lists = (value, label) => {
+			if (value === void 0) return [];
+			if (!Array.isArray(value)) fail(`${name}.${label} must be an array of field lists`);
+			return value.map((v, i) => fieldList(v, `${name}.${label}[${i}]`));
+		};
+		tables.set(name, {
+			name,
+			key,
+			uniques: lists(raw.unique, "unique").map((fields, index) => ({
+				fields,
+				index
+			})),
+			indexes: lists(raw.indexes, "indexes").map((fields, index) => ({
+				fields,
+				index
+			})),
+			refs: [],
+			refsByName: /* @__PURE__ */ new Map(),
+			incoming: [],
+			inverses: /* @__PURE__ */ new Map(),
+			state: void 0
+		});
+	}
+	for (const [name, raw] of Object.entries(config)) {
+		const from = tables.get(name);
+		if (raw.refs === void 0) continue;
+		if (!isRecord(raw.refs)) fail(`${name}.refs must be an object of refs`);
+		for (const [refName, r] of Object.entries(raw.refs)) {
+			const id = `${name}.${refName}`;
+			if (!isRecord(r)) fail(`${id}: ref must be an object`);
+			for (const option of Object.keys(r)) if (!REF_OPTIONS.has(option)) fail(`${id}: unknown option '${option}'`);
+			const fields = fieldList(r.fields, `${id}.fields`);
+			const to = typeof r.to === "string" ? tables.get(r.to) : void 0;
+			if (!to) fail(`${id}.to must name a collection`);
+			let references;
+			if (r.references === void 0) {
+				if (fields.length !== 1 || to.key.length !== 1) fail(`${id}: composite foreign keys need explicit 'references'`);
+				references = [...to.key];
+			} else references = fieldList(r.references, `${id}.references`);
+			if (references.length !== fields.length) fail(`${id}: 'fields' and 'references' must have the same length`);
+			let targetUnique = null;
+			if (!sameList(references, to.key)) {
+				targetUnique = to.uniques.find((u) => sameList(u.fields, references)) ?? null;
+				if (!targetUnique) fail(`${id}: 'references' must be the key or a unique key of '${to.name}', in order`);
+			}
+			const onDelete = r.onDelete;
+			if (!ACTIONS.includes(onDelete)) fail(`${id}.onDelete must be one of ${ACTIONS.join(", ")}`);
+			const onUpdate = r.onUpdate ?? "restrict";
+			if (!ACTIONS.includes(onUpdate)) fail(`${id}.onUpdate must be one of ${ACTIONS.join(", ")}`);
+			const nullFields = r.setNullFields === void 0 ? fields : fieldList(r.setNullFields, `${id}.setNullFields`);
+			if (!nullFields.every((f) => fields.includes(f))) fail(`${id}: 'setNullFields' must be a subset of 'fields'`);
+			if (r.inverse !== void 0 && typeof r.inverse !== "string") fail(`${id}.inverse must be a string`);
+			const ref = {
+				name: refName,
+				id,
+				index: from.refs.length,
+				from,
+				to,
+				fields,
+				references,
+				targetUnique,
+				onDelete,
+				onUpdate,
+				nullFields,
+				inverse: r.inverse,
+				inverseSingle: sameSet(fields, from.key) || from.uniques.some((u) => sameSet(u.fields, fields))
+			};
+			from.refs.push(ref);
+			from.refsByName.set(refName, ref);
+			to.incoming.push(ref);
+		}
+	}
+	for (const table of tables.values()) {
+		for (const ref of table.refs) {
+			if (ref.inverse === void 0) continue;
+			const target = ref.to;
+			if (target.refsByName.has(ref.inverse) || target.inverses.has(ref.inverse)) fail(`${ref.id}: inverse '${ref.inverse}' is already a relation of '${target.name}'`);
+			target.inverses.set(ref.inverse, ref);
+		}
+		for (const ref of table.refs) {
+			if (ref.onDelete !== "setNull" && ref.onUpdate !== "setNull") continue;
+			for (const other of table.refs) if (other !== ref && other.fields.some((f) => ref.nullFields.includes(f))) fail(`${ref.id}: setNull would clear a column ${other.id} shares; use 'setNullFields' to clear only the others`);
+		}
+		table.state = emptyState(table);
+	}
+	return tables;
+}
+// src/store.ts
+/**
+* The engine: storage, index maintenance, reads, writes, the undo log and snapshots.
+*
+* Every write runs inside a savepoint of the undo log. Each primitive change (store a row,
+* remove a row, add to or remove from an index) appends its inverse, so a write that throws
+* midway is rolled back and the store is unchanged. Integrity checks run at the end of each
+* write against the final state, which is what lets a batch reference rows later in the same
+* batch, and a delete remove a row together with the rows `restrict`-ing it.
+*/
+const MAX_CASCADE_DEPTH = 1e3;
+function bySeq(a, b) {
+	return a.seq - b.seq;
+}
+/** Sorts entries into insertion order, skipping the sort when they already are. */
+function inOrder(entries) {
+	for (let i = 1; i < entries.length; i++) if (entries[i - 1].seq > entries[i].seq) return entries.sort(bySeq);
+	return entries;
+}
+function isInCondition(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const proto = Object.getPrototypeOf(value);
+	if (proto !== Object.prototype && proto !== null) return false;
+	const keys = Object.keys(value);
+	return keys.length === 1 && keys[0] === "in" && Array.isArray(value.in);
+}
+/** Every combination of one encoded value per field, encoded as a tuple. */
+function combine(parts) {
+	if (parts.length === 1) return [...parts[0]];
+	let out = [[]];
+	for (const part of parts) {
+		const next = [];
+		for (const prefix of out) for (const v of part) next.push([...prefix, v]);
+		out = next;
+	}
+	return out.map((tuple) => `[${tuple.map((v) => JSON.stringify(v)).join(",")}]`);
+}
+function cloneBuckets(map) {
+	const out = /* @__PURE__ */ new Map();
+	for (const [k, s] of map) out.set(k, new Set(s));
+	return out;
+}
+function cloneState(state) {
+	return {
+		rows: new Map(state.rows),
+		uniques: state.uniques.map((m) => new Map(m)),
+		indexes: state.indexes.map(cloneBuckets),
+		reverse: state.reverse.map(cloneBuckets),
+		seq: state.seq
+	};
+}
+function isNullish(value) {
+	return value === null || value === void 0;
+}
+function push(target, name, row) {
+	const list = target[name];
+	if (list) list.push(row);
+	else target[name] = [row];
+}
+var Store = class {
+	tables;
+	paths = /* @__PURE__ */ new Map();
+	journal = null;
+	constructor(config) {
+		this.tables = buildModel(config);
+		for (const table of this.tables.values()) {
+			const paths = [{
+				fields: table.key,
+				skipsNulls: false,
+				lookup: (s, k) => s.rows.has(k) ? k : void 0
+			}];
+			for (const u of table.uniques) paths.push({
+				fields: u.fields,
+				skipsNulls: true,
+				lookup: (s, k) => s.uniques[u.index].get(k)
+			});
+			for (const ref of table.refs) paths.push({
+				fields: ref.fields,
+				skipsNulls: true,
+				lookup: (s, k) => s.reverse[ref.index].get(k)
+			});
+			for (const idx of table.indexes) paths.push({
+				fields: idx.fields,
+				skipsNulls: false,
+				lookup: (s, k) => s.indexes[idx.index].get(k)
+			});
+			this.paths.set(table, paths);
+		}
+	}
+	/** Runs `fn`; if it throws, undoes everything it changed. Nests. */
+	savepoint(fn) {
+		const outer = this.journal;
+		const journal = outer ?? [];
+		const mark = journal.length;
+		this.journal = journal;
+		try {
+			const result = fn();
+			if (typeof result === "object" && result !== null && typeof result.then === "function") throw new MemrelError("INVALID_ARGUMENT", "Transaction callbacks must be synchronous");
+			return result;
+		} catch (error) {
+			while (journal.length > mark) journal.pop()();
+			throw error;
+		} finally {
+			this.journal = outer;
+		}
+	}
+	log(undo) {
+		this.journal?.push(undo);
+	}
+	mapSet(map, key, value) {
+		if (map.has(key)) {
+			const prev = map.get(key);
+			this.log(() => map.set(key, prev));
+		} else this.log(() => map.delete(key));
+		map.set(key, value);
+	}
+	mapDelete(map, key) {
+		if (!map.has(key)) return;
+		const prev = map.get(key);
+		map.delete(key);
+		this.log(() => map.set(key, prev));
+	}
+	bucketAdd(map, key, member) {
+		let bucket = map.get(key);
+		if (!bucket) {
+			bucket = /* @__PURE__ */ new Set();
+			this.mapSet(map, key, bucket);
+		}
+		if (bucket.has(member)) return;
+		bucket.add(member);
+		const b = bucket;
+		this.log(() => b.delete(member));
+	}
+	bucketDelete(map, key, member) {
+		const bucket = map.get(key);
+		if (!bucket?.delete(member)) return;
+		this.log(() => bucket.add(member));
+		if (bucket.size === 0) this.mapDelete(map, key);
+	}
+	/** Runs one write: rolled back as a whole, and checked once complete. */
+	write(fn) {
+		return this.savepoint(() => {
+			const op = {
+				touched: [],
+				vacated: []
+			};
+			const result = fn(op);
+			this.verify(op);
+			return result;
+		});
+	}
+	/**
+	* The encoded foreign key of `row` for `ref`: `null` when it references nothing (all of the
+	* ref's null fields are null), `undefined` when it is partly null, which is an error.
+	*/
+	foreignKey(ref, row) {
+		if (ref.nullFields.every((f) => isNullish(row[f]))) return null;
+		if (ref.fields.some((f) => isNullish(row[f]))) return void 0;
+		return encodeFields(row, ref.fields);
+	}
+	/** The encoded values of `row` that `ref` points at, or `null` when they aren't indexed. */
+	referencedValue(ref, row) {
+		if (ref.targetUnique && ref.references.some((f) => isNullish(row[f]))) return null;
+		return encodeFields(row, ref.references);
+	}
+	findTarget(ref, value) {
+		const state = ref.to.state;
+		if (!ref.targetUnique) return state.rows.get(value);
+		const pk = state.uniques[ref.targetUnique.index].get(value);
+		return pk === void 0 ? void 0 : state.rows.get(pk);
+	}
+	describe(table, row) {
+		return `${table.name} ${displayKey(row, table.key)}`;
+	}
+	verify(op) {
+		for (const v of op.vacated) {
+			const children = v.ref.from.state.reverse[v.ref.index].get(v.value);
+			if (!children || children.size === 0 || this.findTarget(v.ref, v.value)) continue;
+			const n = children.size;
+			throw new MemrelError("RESTRICT_VIOLATION", `Cannot ${v.verb} ${this.describe(v.ref.to, v.row)}: restricted by ${n} ${n === 1 ? "row" : "rows"} in ${v.ref.id}`);
+		}
+		for (const [table, pk] of op.touched) {
+			const entry = table.state.rows.get(pk);
+			if (entry) this.checkRefs(table, entry.row);
+		}
+	}
+	checkRefs(table, row) {
+		for (const ref of table.refs) {
+			const fk = this.foreignKey(ref, row);
+			if (fk === null) continue;
+			if (fk === void 0) throw new MemrelError("FOREIGN_KEY_VIOLATION", `${this.describe(table, row)}: foreign key ${ref.id} ${displayKey(row, ref.fields)} is partly null`);
+			if (!this.findTarget(ref, fk)) throw new MemrelError("FOREIGN_KEY_VIOLATION", `${this.describe(table, row)}: ${ref.id} references missing ${ref.to.name} ${displayKey(row, ref.fields)}`);
+		}
+	}
+	uniqueValue(row, fields) {
+		return fields.some((f) => isNullish(row[f])) ? null : encodeFields(row, fields);
+	}
+	addRow(op, table, pk, row, seq) {
+		const s = table.state;
+		for (const u of table.uniques) {
+			const value = this.uniqueValue(row, u.fields);
+			if (value === null) continue;
+			const map = s.uniques[u.index];
+			const holder = map.get(value);
+			if (holder !== void 0 && holder !== pk) throw new MemrelError("UNIQUE_VIOLATION", `${this.describe(table, row)}: unique key (${u.fields.join(", ")}) ${displayKey(row, u.fields)} is already taken by ${this.describe(table, s.rows.get(holder).row)}`);
+			this.mapSet(map, value, pk);
+		}
+		for (const idx of table.indexes) this.bucketAdd(s.indexes[idx.index], encodeFields(row, idx.fields), pk);
+		for (const ref of table.refs) {
+			const fk = this.foreignKey(ref, row);
+			if (typeof fk === "string") this.bucketAdd(s.reverse[ref.index], fk, pk);
+		}
+		this.mapSet(s.rows, pk, {
+			row,
+			seq
+		});
+		op.touched.push([table, pk]);
+	}
+	removeRow(table, pk, row) {
+		const s = table.state;
+		for (const u of table.uniques) {
+			const value = this.uniqueValue(row, u.fields);
+			if (value !== null && s.uniques[u.index].get(value) === pk) this.mapDelete(s.uniques[u.index], value);
+		}
+		for (const idx of table.indexes) this.bucketDelete(s.indexes[idx.index], encodeFields(row, idx.fields), pk);
+		for (const ref of table.refs) {
+			const fk = this.foreignKey(ref, row);
+			if (typeof fk === "string") this.bucketDelete(s.reverse[ref.index], fk, pk);
+		}
+		this.mapDelete(s.rows, pk);
+	}
+	get(table, key) {
+		return table.state.rows.get(encodeFields(key, table.key))?.row;
+	}
+	where(table, conditions) {
+		const state = table.state;
+		const conds = /* @__PURE__ */ new Map();
+		for (const field of Object.keys(conditions)) {
+			const raw = conditions[field];
+			if (raw === void 0) continue;
+			const values = isInCondition(raw) ? raw.in : [raw];
+			const encoded = [...new Set(values.map(encodeValue))];
+			conds.set(field, {
+				field,
+				encoded,
+				set: new Set(encoded),
+				hasNull: values.some(isNullish)
+			});
+		}
+		if (conds.size === 0) return inOrder([...state.rows.values()]).map((e) => e.row);
+		let best;
+		for (const path of this.paths.get(table)) {
+			const parts = [];
+			for (const f of path.fields) {
+				const c = conds.get(f);
+				if (!c || path.skipsNulls && c.hasNull) break;
+				parts.push(c.encoded);
+			}
+			if (parts.length !== path.fields.length) continue;
+			const keys = combine(parts);
+			let size = 0;
+			for (const k of keys) {
+				const hit = path.lookup(state, k);
+				if (hit !== void 0) size += typeof hit === "string" ? 1 : hit.size;
+			}
+			if (!best || size < best.size) best = {
+				path,
+				keys,
+				size
+			};
+			if (size === 0) return [];
+		}
+		let candidates;
+		if (best) {
+			const found = [];
+			for (const k of best.keys) {
+				const hit = best.path.lookup(state, k);
+				if (hit === void 0) continue;
+				if (typeof hit === "string") found.push(state.rows.get(hit));
+				else for (const pk of hit) found.push(state.rows.get(pk));
+			}
+			candidates = found;
+		} else candidates = state.rows.values();
+		const checks = [...conds.values()];
+		const out = [];
+		for (const entry of candidates) if (checks.every((c) => c.set.has(encodeValue(entry.row[c.field])))) out.push(entry);
+		return inOrder(out).map((e) => e.row);
+	}
+	rel(table, input, name) {
+		const resolve = (fields) => {
+			if (fields.every((f) => f in input)) return input;
+			return table.state.rows.get(encodeFields(input, table.key))?.row;
+		};
+		const ref = table.refsByName.get(name);
+		if (ref) {
+			const row = resolve(ref.fields);
+			if (!row) throw new MemrelError("NOT_FOUND", `${table.name} ${displayKey(input, table.key)} not found`);
+			const fk = this.foreignKey(ref, row);
+			if (fk === null) return null;
+			const target = fk === void 0 ? void 0 : this.findTarget(ref, fk);
+			if (!target) throw new MemrelError("FOREIGN_KEY_VIOLATION", `${this.describe(table, row)}: ${ref.id} references missing ${ref.to.name} ${displayKey(row, ref.fields)}`);
+			return target.row;
+		}
+		const inverse = table.inverses.get(name);
+		if (inverse) {
+			const row = resolve(inverse.references);
+			const value = row ? this.referencedValue(inverse, row) : null;
+			const child = inverse.from;
+			const bucket = value === null ? void 0 : child.state.reverse[inverse.index].get(value);
+			if (inverse.inverseSingle) {
+				if (!bucket) return void 0;
+				for (const pk of bucket) return child.state.rows.get(pk).row;
+				return;
+			}
+			if (!bucket) return [];
+			const entries = [];
+			for (const pk of bucket) entries.push(child.state.rows.get(pk));
+			return inOrder(entries).map((e) => e.row);
+		}
+		const names = [...table.refsByName.keys(), ...table.inverses.keys()];
+		throw new MemrelError("INVALID_ARGUMENT", `'${name}' is not a relation of ${table.name}${names.length ? `; expected one of: ${names.join(", ")}` : ""}`);
+	}
+	insertRow(op, table, input, mode) {
+		const row = { ...input };
+		const pk = encodeFields(row, table.key);
+		if (!table.state.rows.get(pk)) this.addRow(op, table, pk, row, table.state.seq++);
+		else if (mode === "replace") this.updateRows(op, table, [[pk, row]], 0);
+		else if (mode === "throw") throw new MemrelError("DUPLICATE_KEY", `${this.describe(table, row)} already exists`);
+		return pk;
+	}
+	insert(table, input, mode) {
+		return this.write((op) => {
+			if (!Array.isArray(input)) {
+				const pk = this.insertRow(op, table, input, mode);
+				return () => table.state.rows.get(pk).row;
+			}
+			const pks = input.map((row) => this.insertRow(op, table, row, mode));
+			return () => pks.map((pk) => table.state.rows.get(pk).row);
+		})();
+	}
+	load(data, mode) {
+		this.write((op) => {
+			for (const [name, rows] of Object.entries(data)) {
+				if (rows === void 0) continue;
+				const table = this.table(name);
+				for (const row of rows) this.insertRow(op, table, row, mode);
+			}
+		});
+	}
+	table(name) {
+		const table = this.tables.get(name);
+		if (!table) throw new MemrelError("INVALID_ARGUMENT", `'${name}' is not a collection`);
+		return table;
+	}
+	update(table, keys, patch) {
+		return this.write((op) => {
+			const many = Array.isArray(keys);
+			const list = many ? keys : [keys];
+			const changes = /* @__PURE__ */ new Map();
+			const pks = list.map((key) => {
+				const pk = encodeFields(key, table.key);
+				const entry = table.state.rows.get(pk);
+				if (!entry) throw new MemrelError("NOT_FOUND", `${table.name} ${displayKey(key, table.key)} not found`);
+				if (!changes.has(pk)) {
+					const p = typeof patch === "function" ? patch(entry.row) : patch;
+					changes.set(pk, {
+						...entry.row,
+						...p
+					});
+				}
+				return pk;
+			});
+			const newPks = this.updateRows(op, table, [...changes], 0);
+			const moved = new Map([...changes.keys()].map((pk, i) => [pk, newPks[i]]));
+			return () => {
+				const rows = pks.map((pk) => table.state.rows.get(moved.get(pk)).row);
+				return many ? rows : rows[0];
+			};
+		})();
+	}
+	/**
+	* Replaces rows and applies the `onUpdate` rules of refs pointing at changed values. All old
+	* rows leave the indexes before the new ones enter, so rows in one call may swap keys.
+	* Returns the new primary keys, in order.
+	*/
+	updateRows(op, table, changes, depth) {
+		if (depth > MAX_CASCADE_DEPTH) throw new MemrelError("INVALID_ARGUMENT", `Cascade through ${table.name} doesn't terminate`);
+		const s = table.state;
+		const olds = changes.map(([pk]) => s.rows.get(pk));
+		for (let i = 0; i < changes.length; i++) this.removeRow(table, changes[i][0], olds[i].row);
+		const newPks = changes.map(([, row], i) => {
+			const pk = encodeFields(row, table.key);
+			if (s.rows.has(pk)) throw new MemrelError("DUPLICATE_KEY", `Cannot update ${this.describe(table, olds[i].row)}: ${this.describe(table, row)} already exists`);
+			this.addRow(op, table, pk, row, olds[i].seq);
+			return pk;
+		});
+		for (const ref of table.incoming) {
+			const child = ref.from;
+			const childChanges = /* @__PURE__ */ new Map();
+			for (let i = 0; i < changes.length; i++) {
+				const row = changes[i][1];
+				const oldRow = olds[i].row;
+				const before = this.referencedValue(ref, oldRow);
+				if (before === null || before === this.referencedValue(ref, row)) continue;
+				const bucket = child.state.reverse[ref.index].get(before);
+				if (!bucket || bucket.size === 0) continue;
+				if (ref.onUpdate === "restrict") {
+					op.vacated.push({
+						ref,
+						value: before,
+						verb: "update",
+						row: oldRow
+					});
+					continue;
+				}
+				for (const childPk of bucket) {
+					const next = { ...childChanges.get(childPk) ?? child.state.rows.get(childPk).row };
+					if (ref.onUpdate === "cascade") for (let j = 0; j < ref.fields.length; j++) next[ref.fields[j]] = row[ref.references[j]];
+					else for (const f of ref.nullFields) next[f] = null;
+					childChanges.set(childPk, next);
+				}
+			}
+			if (childChanges.size > 0) this.updateRows(op, child, [...childChanges], depth + 1);
+		}
+		return newPks;
+	}
+	delete(roots) {
+		return this.write((op) => {
+			const plan = /* @__PURE__ */ new Map();
+			const queue = [];
+			const planned = (table) => {
+				let rows = plan.get(table);
+				if (!rows) {
+					rows = /* @__PURE__ */ new Map();
+					plan.set(table, rows);
+				}
+				return rows;
+			};
+			for (const [table, key] of roots) {
+				const pk = encodeFields(key, table.key);
+				const entry = table.state.rows.get(pk);
+				if (!entry) throw new MemrelError("NOT_FOUND", `${table.name} ${displayKey(key, table.key)} not found`);
+				const rows = planned(table);
+				if (rows.has(pk)) continue;
+				rows.set(pk, entry.row);
+				queue.push([table, entry.row]);
+			}
+			const nulls = /* @__PURE__ */ new Map();
+			for (let i = 0; i < queue.length; i++) {
+				const [table, row] = queue[i];
+				for (const ref of table.incoming) {
+					const value = this.referencedValue(ref, row);
+					if (value === null) continue;
+					const child = ref.from;
+					const bucket = child.state.reverse[ref.index].get(value);
+					if (!bucket || bucket.size === 0) continue;
+					if (ref.onDelete === "restrict") op.vacated.push({
+						ref,
+						value,
+						verb: "delete",
+						row
+					});
+					else if (ref.onDelete === "cascade") {
+						const rows = planned(child);
+						for (const childPk of bucket) {
+							if (rows.has(childPk)) continue;
+							const childRow = child.state.rows.get(childPk).row;
+							rows.set(childPk, childRow);
+							queue.push([child, childRow]);
+						}
+					} else {
+						let byPk = nulls.get(child);
+						if (!byPk) {
+							byPk = /* @__PURE__ */ new Map();
+							nulls.set(child, byPk);
+						}
+						for (const childPk of bucket) {
+							const refs = byPk.get(childPk);
+							if (refs) refs.push(ref);
+							else byPk.set(childPk, [ref]);
+						}
+					}
+				}
+			}
+			const outcome = {
+				deleted: {},
+				nulled: {}
+			};
+			for (const [table, rows] of plan) for (const [pk, row] of rows) {
+				this.removeRow(table, pk, row);
+				push(outcome.deleted, table.name, row);
+			}
+			const nulled = [];
+			for (const [table, byPk] of nulls) {
+				const changes = [];
+				for (const [pk, refs] of byPk) {
+					const entry = table.state.rows.get(pk);
+					if (!entry) continue;
+					const next = { ...entry.row };
+					for (const ref of refs) for (const f of ref.nullFields) next[f] = null;
+					changes.push([pk, next]);
+				}
+				if (changes.length > 0) nulled.push([table, this.updateRows(op, table, changes, 0)]);
+			}
+			return () => {
+				for (const [table, pks] of nulled) for (const pk of pks) {
+					const entry = table.state.rows.get(pk);
+					if (entry) push(outcome.nulled, table.name, entry.row);
+				}
+				return outcome;
+			};
+		})();
+	}
+	snapshot() {
+		const states = /* @__PURE__ */ new Map();
+		for (const table of this.tables.values()) states.set(table, cloneState(table.state));
+		return {
+			store: this,
+			states
+		};
+	}
+	restore(snapshot) {
+		if (snapshot?.store !== this) throw new MemrelError("INVALID_ARGUMENT", "Snapshot was not taken from this database");
+		this.savepoint(() => {
+			for (const table of this.tables.values()) {
+				const prev = table.state;
+				table.state = cloneState(snapshot.states.get(table));
+				this.log(() => {
+					table.state = prev;
+				});
+			}
+		});
+	}
+};
+// src/db.ts
+function conflictMode(options) {
+	const mode = options?.onConflict ?? "throw";
+	if (mode !== "throw" && mode !== "ignore" && mode !== "replace") throw new MemrelError("INVALID_ARGUMENT", `Unknown onConflict mode '${String(mode)}'`);
+	return mode;
+}
+var CollectionApi = class {
+	#store;
+	#table;
+	constructor(store, table) {
+		this.#store = store;
+		this.#table = table;
+	}
+	get(key) {
+		return this.#store.get(this.#table, key);
+	}
+	where(conditions) {
+		return this.#store.where(this.#table, conditions);
+	}
+	rel(row, name) {
+		return this.#store.rel(this.#table, row, name);
+	}
+	insert(rows, options) {
+		return this.#store.insert(this.#table, rows, conflictMode(options));
+	}
+	update(keys, patch) {
+		return this.#store.update(this.#table, keys, patch);
+	}
+	delete(keys) {
+		const list = Array.isArray(keys) ? keys : [keys];
+		return this.#store.delete(list.map((key) => [this.#table, key]));
+	}
+};
+/**
+* Creates a database. The double call is deliberate: the first call fixes the row types, the
+* second infers the exact config, which TypeScript can't do in one call.
+*
+* @example
+* ```ts
+* const db = createDb<{ user: User; post: Post }>()({
+*   user: { key: ['id'], unique: [['email']] },
+*   post: {
+*     key: ['id'],
+*     refs: {
+*       author: { fields: ['authorId'], to: 'user', onDelete: 'cascade', inverse: 'posts' },
+*     },
+*   },
+* });
+* ```
+*/
+function createDb() {
+	return defineDb;
+}
+function defineDb(config) {
+	const store = new Store(config);
+	const db = {
+		load(data, options) {
+			store.load(data, conflictMode(options));
+		},
+		remove(keys) {
+			const roots = [];
+			for (const [name, list] of Object.entries(keys)) {
+				const table = store.table(name);
+				for (const key of list ?? []) roots.push([table, key]);
+			}
+			return store.delete(roots);
+		},
+		transaction(fn) {
+			return store.savepoint(fn);
+		},
+		snapshot() {
+			return store.snapshot();
+		},
+		restore(snapshot) {
+			store.restore(snapshot);
+		}
+	};
+	for (const table of store.tables.values()) db[table.name] = new CollectionApi(store, table);
+	return db;
+}
+export { MemrelError, createDb };
+
+//# sourceMappingURL=index.js.map