@atscript/db-memory 0.1.146 → 0.1.148

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { ALL_AGGREGATE_FNS, ALL_BUCKET_UNITS, BaseDbAdapter, DbError, DbSpace, deletePath, getPath, getPath as getPath$1, isAtscriptDbView, walkFilter } from "@atscript/db";
+import { ALL_AGGREGATE_FNS, ALL_BUCKET_UNITS, ALL_VIEW_CAPABILITIES, BaseDbAdapter, DbError, DbSpace, containsRelationFilter, deletePath, evaluateExpr, forEachResolvedRelation, getPath, getPath as getPath$1, isAtscriptDbView, isConflict, isResolvedRelationFilter, walkFilter } from "@atscript/db";
 import { assertAggregateFn, resolveAlias } from "@atscript/db/agg";
 import { bucketer } from "@uniqu/core";
 //#region src/lib/memory-filter.ts
@@ -73,15 +73,26 @@ function stringifyLeaf(v) {
 /** `$eq` semantics, factored out so `$ne` can be its exact negation. */
 function evalEq(row, field, value) {
 	const fieldValue = getPath$1(row, field);
-	if (value === null) return fieldValue == null;
+	if (value === null) return matchesScalar(fieldValue, null);
 	if (value instanceof RegExp) return fieldValue != null && value.test(stringifyLeaf(fieldValue));
+	return matchesScalar(fieldValue, value);
+}
+/**
+* Mongo containment: a scalar compared with an array field matches when ANY element
+* equals it (`{ labels: "bug" }` matches `["bug", "ui"]`). Non-array fields compare as before.
+* `null` also matches a missing field (`undefined`) and an array holding a `null` element,
+* as `{ labels: null }` / `$in: [null]` do in Mongo.
+*/
+function matchesScalar(fieldValue, value) {
+	if (value === null) return fieldValue == null || Array.isArray(fieldValue) && fieldValue.includes(null);
+	if (Array.isArray(fieldValue) && !Array.isArray(value)) return fieldValue.some((el) => valuesEqual(el, value));
 	return valuesEqual(fieldValue, value);
 }
 /** `$in` membership, factored out so `$nin` can be its exact negation. */
 function evalIn(row, field, value) {
 	if (!Array.isArray(value)) return false;
 	const fieldValue = getPath$1(row, field);
-	return value.some((element) => valuesEqual(fieldValue, element));
+	return value.some((element) => matchesScalar(fieldValue, element));
 }
 /**
 * Coerce a leaf to something the JS relational operators can order. `Date`s
@@ -155,18 +166,156 @@ const memoryVisitor = {
 				message: `Unsupported filter operator: ${op}`
 			}]);
 		}
+	},
+	relation(field, op, operand) {
+		return relationPredicate(void 0, field, op, operand);
 	}
 };
 /**
+* Identity of the key tuple `fields` of `row` (dot-paths read nested), or
+* `undefined` when a component is `null` / missing — a NULL key component
+* never correlates (SQL `=` semantics: `$some` false, `$none` true).
+* Every component is type-tagged (see {@link keyPart}), matching the strict
+* equality the memory filter uses everywhere (`valuesEqual`): `1` ≠ `"1"`,
+* `5n` ≠ `"5n"`, a `Date` ≠ its ISO string; `Date`s compare by instant.
+*/
+function correlationKey(row, fields) {
+	const parts = [];
+	for (const field of fields) {
+		const part = keyPart(getPath$1(row, field));
+		if (part === void 0) return;
+		parts.push(part);
+	}
+	return JSON.stringify(parts);
+}
+/**
+* Type-tagged identity of one key component, or `undefined` when it never
+* equals anything (`null` / missing, `NaN`).
+*/
+function keyPart(value) {
+	switch (typeof value) {
+		case "string": return `s:${value}`;
+		case "number": return Number.isNaN(value) ? void 0 : `n:${value === 0 ? 0 : value}`;
+		case "bigint": return `b:${value}`;
+		case "boolean": return `t:${value}`;
+		case "undefined": return;
+		default:
+			if (value === null) return void 0;
+			if (value instanceof Date) {
+				const time = value.getTime();
+				return Number.isNaN(time) ? void 0 : `d:${time}`;
+			}
+			return `o:${JSON.stringify(value, (_k, v) => typeof v === "bigint" ? `${v}n` : v)}`;
+	}
+}
+/** Source-side correlation columns of a resolved predicate (physical names). */
+function sourceColumns(node) {
+	return node.junction ? node.junction.toSource.map((p) => p.source) : node.pairs.map((p) => p.source);
+}
+/**
+* The visitor's `relation` callback: a row satisfies `$some` when its source
+* correlation tuple is in the predicate's prepared set, `$none` otherwise.
+*/
+function relationPredicate(sets, field, op, operand) {
+	const node = operand;
+	const set = isResolvedRelationFilter(node) ? sets?.get(node) : void 0;
+	if (!set) throw new DbError("REL_FILTER_NOT_SUPPORTED", [{
+		path: field,
+		message: `Relational predicate "${op}" on "${field}" was not prepared — call prepareRelationSets() before buildMemoryPredicate()`
+	}]);
+	const columns = sourceColumns(node);
+	const some = op === "$some";
+	return (row) => {
+		const key = correlationKey(row, columns);
+		return (key !== void 0 && set.has(key)) === some;
+	};
+}
+/**
+* Resolves every relational predicate of a TRANSLATED filter (nested ones
+* included) into a correlation set, loading each related table through
+* `load`:
+*
+* - `to` / `from`: the related rows matching the inner filter contribute their
+*   `pairs[].target` tuples — equal to the source tuple (`pairs[].source`) of
+*   every row that has such a related row.
+* - `via`: the matching related rows' `junction.toTarget[].target` tuples
+*   select junction rows (also filtered by the junction part of
+*   `@db.rel.filter`), which contribute their `junction.toSource[].junction`
+*   tuples.
+*
+* Nested predicates are prepared against the related table's rows first
+* (their source is this predicate's target). Returns `undefined` when the
+* filter holds no predicate — callers then stay on the plain synchronous path.
+*
+* @since 0.1.147
+*/
+async function prepareRelationSets(filter, load) {
+	if (!containsRelationFilter(filter)) return;
+	const sets = /* @__PURE__ */ new Map();
+	await prepareLevel(filter, load, sets);
+	return sets;
+}
+/** Prepares the predicates at one level of `filter` (and, recursively, their operands). */
+async function prepareLevel(filter, load, sets) {
+	const nodes = [];
+	forEachResolvedRelation(filter, (node) => nodes.push(node), false);
+	for (const node of nodes) if (!sets.has(node)) sets.set(node, await correlationSet(node, load, sets));
+}
+/** Matching rows of `adapter`'s table for `filter` (its own predicates prepared first). */
+async function matchingRows(adapter, filter, load, sets) {
+	const rows = await load(adapter);
+	if (!filter || Object.keys(filter).length === 0) return rows;
+	await prepareLevel(filter, load, sets);
+	return rows.filter(buildMemoryPredicate(filter, sets));
+}
+/** The source correlation tuples that have a related row matching `node`. */
+async function correlationSet(node, load, sets) {
+	const targets = await matchingRows(node.target.adapter, node.filter, load, sets);
+	const result = /* @__PURE__ */ new Set();
+	if (!node.junction) {
+		const columns = node.pairs.map((p) => p.target);
+		for (const row of targets) {
+			const key = correlationKey(row, columns);
+			if (key !== void 0) result.add(key);
+		}
+		return result;
+	}
+	const { junction } = node;
+	const targetKeys = /* @__PURE__ */ new Set();
+	const targetColumns = junction.toTarget.map((p) => p.target);
+	for (const row of targets) {
+		const key = correlationKey(row, targetColumns);
+		if (key !== void 0) targetKeys.add(key);
+	}
+	if (targetKeys.size === 0) return result;
+	const toTarget = junction.toTarget.map((p) => p.junction);
+	const toSource = junction.toSource.map((p) => p.junction);
+	for (const row of await matchingRows(junction.adapter, junction.filter, load, sets)) {
+		const targetKey = correlationKey(row, toTarget);
+		if (targetKey === void 0 || !targetKeys.has(targetKey)) continue;
+		const sourceKey = correlationKey(row, toSource);
+		if (sourceKey !== void 0) result.add(sourceKey);
+	}
+	return result;
+}
+/**
 * Compiles a {@link FilterExpr} into an in-memory row predicate
 * `(row) => boolean`, reusing the shared {@link walkFilter} walker so filter
 * structure matches the SQL/Mongo adapters by construction.
 *
 * An empty/absent filter (for which `walkFilter` returns `undefined`) compiles
 * to a match-everything predicate.
+*
+* A filter holding relational predicates (`ResolvedRelationFilter` operands,
+* since 0.1.147) needs `relationSets` — prepared internally by
+* `MemoryAdapter` from the related tables; a standalone call on such a
+* filter throws `REL_FILTER_NOT_SUPPORTED`.
 */
-function buildMemoryPredicate(filter) {
-	return walkFilter(filter, memoryVisitor) ?? (() => true);
+function buildMemoryPredicate(filter, relationSets) {
+	return walkFilter(filter, relationSets ? {
+		...memoryVisitor,
+		relation: (field, op, operand) => relationPredicate(relationSets, field, op, operand)
+	} : memoryVisitor) ?? (() => true);
 }
 //#endregion
 //#region src/lib/memory-engine.ts
@@ -325,10 +474,28 @@ function projectRow(row, projection, opts) {
 function aggregateRows(rows, controls) {
 	const $select = controls.$select;
 	const groupBy = controls.$groupBy ?? [];
-	const aggregates = $select?.aggregates ?? [];
-	const aliases = aggregates.map((expr) => resolveAlias(expr));
+	const entries = [
+		...($select?.aggregates ?? []).map((expr) => ({
+			alias: resolveAlias(expr),
+			create: accumulatorFactory(expr)
+		})),
+		...($select?.exprAggregates ?? []).map((e) => ({
+			alias: e.alias,
+			create: exprAccumulatorFactory(e)
+		})),
+		...($select?.firstLast ?? []).map((fl) => ({
+			alias: fl.alias,
+			create: firstLastFactory(fl, $select?.rowOrder ?? [])
+		}))
+	];
+	const aliases = entries.map((e) => e.alias);
+	const groupExprs = ($select?.exprs ?? []).map((e) => ({
+		alias: e.alias,
+		expr: e.expr,
+		readers: new Map(e.names.map((name) => [name, pathReader(name)]))
+	}));
 	const keyReaders = groupBy.map((key) => groupKeyReader(key, controls));
-	const accumulators = aggregates.map(accumulatorFactory);
+	const accumulators = entries.map((e) => e.create);
 	const newGroup = (values) => ({
 		values,
 		accs: accumulators.map((create) => create())
@@ -357,6 +524,7 @@ function aggregateRows(rows, controls) {
 		const row = {};
 		for (let i = 0; i < groupBy.length; i++) setPath(row, groupBy[i], values[i]);
 		for (let i = 0; i < aliases.length; i++) row[aliases[i]] = accs[i].result();
+		for (const e of groupExprs) row[e.alias] = evaluateExpr(e.expr, (name) => Object.hasOwn(row, name) ? row[name] : e.readers.get(name)(row));
 		out.push(row);
 	}
 	const having = controls.$having;
@@ -364,7 +532,7 @@ function aggregateRows(rows, controls) {
 	if (controls.$count) return [{ count: out.length }];
 	const paged = paginate(sortRows(out, controls.$sort), controls.$skip, controls.$limit);
 	const fields = ($select === void 0 ? groupBy : $select.asArray ?? []).map((field) => [field, pathReader(field)]);
-	const outputAliases = $select === void 0 ? [] : [...($select.buckets ?? []).map((b) => b.alias), ...aliases];
+	const outputAliases = $select === void 0 ? [] : [...($select.buckets ?? []).map((b) => b.alias), ...$select.computedAliases];
 	return paged.map((row) => {
 		const picked = {};
 		for (const [field, read] of fields) setPath(picked, field, copyValue(read(row) ?? null));
@@ -430,76 +598,109 @@ function numericValue(value) {
 		return Number.isNaN(n) ? void 0 : n;
 	}
 }
+/** `sum` / `avg` / `min` / `max` over a per-row arithmetic expression; NULL results are skipped like NULL fields. */
+function exprAccumulatorFactory(e) {
+	const readers = new Map(e.names.map((name) => [name, pathReader(name)]));
+	return fnAccumulator(e.fn, (row) => evaluateExpr(e.expr, (field) => readers.get(field)(row)));
+}
 /**
-* Resolves an aggregate expression to an accumulator factory (one accumulator
-* per group). Validated up front, so an unknown `$fn` is rejected even when
-* there are no rows.
+* `first` / `last`: the value of `fl.column` on the group's representative
+* row — the least (`first`) or greatest (`last`) row by `rowOrder` (NULL
+* smallest; the primary key is the final key, so the pick is deterministic).
+*/
+function firstLastFactory(fl, rowOrder) {
+	const keys = rowOrder.map((k) => ({
+		read: pathReader(k.column),
+		sign: k.desc ? -1 : 1
+	}));
+	const read = pathReader(fl.column);
+	const sign = fl.fn === "first" ? -1 : 1;
+	const compare = (a, b) => {
+		for (const k of keys) {
+			const c = compareLeaves(k.read(a), k.read(b)) * k.sign;
+			if (c !== 0) return c;
+		}
+		return 0;
+	};
+	return () => {
+		let best;
+		return {
+			add: (row) => {
+				if (best === void 0 || compare(row, best) * sign > 0) best = row;
+			},
+			result: () => best === void 0 ? null : copyValue(read(best) ?? null)
+		};
+	};
+}
+/**
+* `sum` / `avg` / `min` / `max` over the values `read` yields per row — a
+* field's, or a per-row expression's. `sum` / `avg` skip non-numeric values
+* and are `null` over none; `min` / `max` skip null / missing and order with
+* the `$sort` comparator.
+*/
+function fnAccumulator(fn, read) {
+	if (fn === "sum" || fn === "avg") return () => {
+		let sum = 0;
+		let n = 0;
+		return {
+			add: (row) => {
+				const v = numericValue(read(row));
+				if (v !== void 0) {
+					sum += v;
+					n++;
+				}
+			},
+			result: () => n === 0 ? null : fn === "avg" ? sum / n : sum
+		};
+	};
+	const sign = fn === "min" ? -1 : 1;
+	return () => {
+		let best = null;
+		return {
+			add: (row) => {
+				const v = read(row);
+				if (v == null) return;
+				if (best === null || compareLeaves(v, best) * sign > 0) best = v;
+			},
+			result: () => best
+		};
+	};
+}
+/**
+* Resolves a plain aggregate (`first` / `last` are {@link firstLastFactory}'s)
+* to an accumulator factory (one accumulator per group). Validated up front,
+* so an unknown `$fn` is rejected even when there are no rows.
 */
 function accumulatorFactory(expr) {
 	assertAggregateFn(expr.$fn);
 	const field = expr.$field;
 	const read = pathReader(field);
-	switch (expr.$fn) {
-		case "count": {
-			const all = field === "*";
-			return () => {
-				let n = 0;
-				return {
-					add: (row) => {
-						if (all || read(row) != null) n++;
-					},
-					result: () => n
-				};
-			};
-		}
-		case "sum":
-		case "avg": {
-			const avg = expr.$fn === "avg";
-			return () => {
-				let sum = 0;
-				let n = 0;
-				return {
-					add: (row) => {
-						const v = numericValue(read(row));
-						if (v !== void 0) {
-							sum += v;
-							n++;
-						}
-					},
-					result: () => n === 0 ? null : avg ? sum / n : sum
-				};
-			};
-		}
-		case "countDistinct": return () => {
-			const plain = /* @__PURE__ */ new Set();
-			const tokens = /* @__PURE__ */ new Set();
+	if (expr.$fn === "count") {
+		const all = field === "*";
+		return () => {
+			let n = 0;
 			return {
 				add: (row) => {
-					const v = read(row);
-					if (v == null) return;
-					if (typeof v === "string" || typeof v === "boolean") plain.add(v);
-					else tokens.add(identityToken(v));
+					if (all || read(row) != null) n++;
 				},
-				result: () => plain.size + tokens.size
+				result: () => n
 			};
 		};
-		case "min":
-		case "max": {
-			const sign = expr.$fn === "min" ? -1 : 1;
-			return () => {
-				let best = null;
-				return {
-					add: (row) => {
-						const v = read(row);
-						if (v == null) return;
-						if (best === null || compareLeaves(v, best) * sign > 0) best = v;
-					},
-					result: () => best
-				};
-			};
-		}
-		default: return expr.$fn;
 	}
+	if (expr.$fn === "countDistinct") return () => {
+		const plain = /* @__PURE__ */ new Set();
+		const tokens = /* @__PURE__ */ new Set();
+		return {
+			add: (row) => {
+				const v = read(row);
+				if (v == null) return;
+				if (typeof v === "string" || typeof v === "boolean") plain.add(v);
+				else tokens.add(identityToken(v));
+			},
+			result: () => plain.size + tokens.size
+		};
+	};
+	return fnAccumulator(expr.$fn, read);
 }
 //#endregion
 //#region src/lib/memory-adapter.ts
@@ -526,7 +727,7 @@ const databases = /* @__PURE__ */ new WeakMap();
 *   runtime-owned entity with NO database can be observed as a READ-ONLY
 *   atscript table; all writes are rejected (see {@link _assertWritable}).
 */
-var MemoryAdapter = class extends BaseDbAdapter {
+var MemoryAdapter = class MemoryAdapter extends BaseDbAdapter {
 	/**
 	* The in-memory database: the space's (see {@link databases}), resolved once
 	* in {@link registerSpace}; an adapter used without a space keeps this own one.
@@ -582,6 +783,19 @@ var MemoryAdapter = class extends BaseDbAdapter {
 		return !fd.encrypted;
 	}
 	/**
+	* Relational predicates (`{ nav: { $some | $none: … } }`) are evaluated in
+	* reads AND mutation filters. Before a filter holding them is compiled, every
+	* related table (and junction) is loaded ONCE for that operation — through
+	* its own adapter's snapshot seam, so a provider-backed related table works
+	* too — and each predicate becomes a set of matching correlation keys
+	* (see {@link _relationSets}). Predicate-free filters take the plain path.
+	*
+	* @since 0.1.147
+	*/
+	supportsRelationFilters(_mode) {
+		return true;
+	}
+	/**
 	* Coerces a by-id value to the id field's declared leaf type. The framework
 	* calls `adapter.prepareId(value, fieldType)` when building by-id filters, so a
 	* URL id like `"21"` reaches this adapter as the STRING `"21"`. Memory does
@@ -642,14 +856,14 @@ var MemoryAdapter = class extends BaseDbAdapter {
 	/**
 	* Physical names of the primary-key field(s). Single `@meta.id` resolves via
 	* {@link AtscriptDbReadable.metaIdPhysical}; a composite key maps each logical
-	* PK path through `pathToPhysical` (falling back to the name itself). Memoized
+	* PK path through `physicalPath` (`@db.column` renames included). Memoized
 	* because it is stable per adapter (1:1 with a fixed table) yet read on every
 	* `pkKey`/projection — recomputing would re-read `this._table.*` and re-allocate.
 	*/
 	_physicalPkFields() {
 		if (this._pkFieldsCache) return this._pkFieldsCache;
 		const metaIdPhysical = this._table.metaIdPhysical;
-		const fields = metaIdPhysical ? [metaIdPhysical] : this._table.primaryKeys.map((pk) => this._table.pathToPhysical.get(pk) ?? pk);
+		const fields = metaIdPhysical ? [metaIdPhysical] : this._table.primaryKeys.map((pk) => this._table.physicalPath(pk));
 		this._pkFieldsCache = fields;
 		return fields;
 	}
@@ -807,6 +1021,39 @@ var MemoryAdapter = class extends BaseDbAdapter {
 		return [...this._peekState()?.rows.values() ?? []];
 	}
 	/**
+	* A per-operation row loader for relational predicates: each related table
+	* is snapshotted at most once per operation (the first predicate that needs
+	* it loads it; later ones — and nested ones — reuse that snapshot), so a
+	* provider-backed related table is invoked once per read. `own` seeds this
+	* table's snapshot so a self relation reads the same rows as the outer scan.
+	*/
+	_snapshotLoader(own) {
+		const snapshots = /* @__PURE__ */ new Map();
+		if (own) snapshots.set(this, own);
+		return (adapter) => {
+			let rows = snapshots.get(adapter);
+			if (!rows) {
+				if (!(adapter instanceof MemoryAdapter)) throw new DbError("REL_FILTER_NOT_SUPPORTED", [{
+					path: "",
+					message: "Relational predicate: the related table is not served by the memory adapter"
+				}]);
+				rows = Promise.resolve(adapter._loadRows());
+				snapshots.set(adapter, rows);
+			}
+			return rows;
+		};
+	}
+	/**
+	* The prepared correlation sets for `filter`'s relational predicates.
+	* Callers only await it when `containsRelationFilter(filter)` — a
+	* predicate-free filter keeps its fully synchronous path. Write methods call
+	* it BEFORE reading the table state, so the related tables (a self relation
+	* included) are snapshotted before any row changes, like SQL.
+	*/
+	async _relationSets(filter, own) {
+		return prepareRelationSets(filter, this._snapshotLoader(own));
+	}
+	/**
 	* Clones the payload in, applies the version default, generates any
 	* `@db.default.increment` values, enforces PK + unique constraints, stores
 	* the row, and returns the resolved inserted id. Clone-in (`structuredClone`)
@@ -875,6 +1122,22 @@ var MemoryAdapter = class extends BaseDbAdapter {
 			insertedIds
 		};
 	}
+	supportsInsertIgnore() {
+		return true;
+	}
+	/** A row colliding on the primary key or a unique index (`CONFLICT`) becomes a skipped slot. */
+	async insertManyIgnore(data) {
+		this._assertWritable();
+		const state = this._state();
+		return data.map((item) => {
+			try {
+				return { insertedId: this._insertRow(state, item) };
+			} catch (error) {
+				if (isConflict(error)) return null;
+				throw error;
+			}
+		});
+	}
 	/**
 	* Selects the stored rows a write should touch, as `{ key, row }` pairs so
 	* callers can mutate in place and re-key. Stored mode scans the table's Map
@@ -890,11 +1153,14 @@ var MemoryAdapter = class extends BaseDbAdapter {
 	*
 	* When `many` is `false` at most the first match is returned. A table that
 	* does not exist (`state` undefined) matches nothing and is not created.
+	*
+	* A filter with relational predicates needs `relationSets`, prepared by the
+	* caller BEFORE it reads `state` (see {@link _relationSets}).
 	*/
-	_selectForWrite(state, filter, expectedVersion, many) {
+	_selectForWrite(state, filter, expectedVersion, many, relationSets) {
 		const versionColumn = this._table.versionColumnPhysical;
 		if (expectedVersion !== void 0 && versionColumn === void 0) throw new Error("expectedVersion requires a versioned table");
-		const match = buildMemoryPredicate(filter);
+		const match = buildMemoryPredicate(filter, relationSets);
 		const matched = [];
 		for (const [key, row] of state?.rows ?? []) {
 			if (!match(row)) continue;
@@ -974,8 +1240,9 @@ var MemoryAdapter = class extends BaseDbAdapter {
 	}
 	async replaceOne(filter, data, expectedVersion) {
 		this._assertWritable();
+		const sets = containsRelationFilter(filter) ? await this._relationSets(filter) : void 0;
 		const state = this._peekState();
-		const matched = this._selectForWrite(state, filter, expectedVersion, false);
+		const matched = this._selectForWrite(state, filter, expectedVersion, false, sets);
 		if (!state || matched.length === 0) return {
 			matchedCount: 0,
 			modifiedCount: 0
@@ -992,8 +1259,9 @@ var MemoryAdapter = class extends BaseDbAdapter {
 	}
 	async updateOne(filter, data, ops, expectedVersion) {
 		this._assertWritable();
+		const sets = containsRelationFilter(filter) ? await this._relationSets(filter) : void 0;
 		const state = this._peekState();
-		const matched = this._selectForWrite(state, filter, expectedVersion, false);
+		const matched = this._selectForWrite(state, filter, expectedVersion, false, sets);
 		if (!state || matched.length === 0) return {
 			matchedCount: 0,
 			modifiedCount: 0
@@ -1007,8 +1275,9 @@ var MemoryAdapter = class extends BaseDbAdapter {
 	}
 	async deleteOne(filter) {
 		this._assertWritable();
+		const sets = containsRelationFilter(filter) ? await this._relationSets(filter) : void 0;
 		const state = this._peekState();
-		const matched = this._selectForWrite(state, filter, void 0, false);
+		const matched = this._selectForWrite(state, filter, void 0, false, sets);
 		if (!state || matched.length === 0) return { deletedCount: 0 };
 		state.rows.delete(matched[0].key);
 		return { deletedCount: 1 };
@@ -1060,8 +1329,14 @@ var MemoryAdapter = class extends BaseDbAdapter {
 	* working set — one provider invocation per logical read.
 	*/
 	async _filteredRows(query) {
-		const match = buildMemoryPredicate(query.filter);
-		return (await this._loadRows()).filter(match);
+		if (!containsRelationFilter(query.filter)) {
+			const match = buildMemoryPredicate(query.filter);
+			return (await this._loadRows()).filter(match);
+		}
+		const own = Promise.resolve(this._loadRows());
+		own.catch(() => {});
+		const sets = await this._relationSets(query.filter, own);
+		return (await own).filter(buildMemoryPredicate(query.filter, sets));
 	}
 	async findOne(query) {
 		const filtered = await this._filteredRows(query);
@@ -1112,18 +1387,27 @@ var MemoryAdapter = class extends BaseDbAdapter {
 	calendarBucketUnits() {
 		return ALL_BUCKET_UNITS;
 	}
-	/** Every aggregate function, `countDistinct` included. */
+	/** Every aggregate function: `countDistinct`, `first` and `last` included. */
 	aggregateFns() {
 		return ALL_AGGREGATE_FNS;
 	}
+	/** Arithmetic in an aggregate `$select` (`{ $expr }`, `{ $fn, $expr }`). */
+	supportsAggregateExpressions() {
+		return true;
+	}
+	/** Managed views render nothing (non-goal) — both are accepted like `aggregateFns()`. */
+	viewCapabilities() {
+		return ALL_VIEW_CAPABILITIES;
+	}
 	async updateMany(filter, data, ops) {
 		this._assertWritable();
+		const sets = containsRelationFilter(filter) ? await this._relationSets(filter) : void 0;
 		const state = this._peekState();
 		if (!state) return {
 			matchedCount: 0,
 			modifiedCount: 0
 		};
-		const matched = this._selectForWrite(state, filter, void 0, true);
+		const matched = this._selectForWrite(state, filter, void 0, true, sets);
 		for (const { key, row } of matched) this._commitUpdate(state, key, row, data, ops);
 		return {
 			matchedCount: matched.length,
@@ -1132,12 +1416,13 @@ var MemoryAdapter = class extends BaseDbAdapter {
 	}
 	async replaceMany(filter, data) {
 		this._assertWritable();
+		const sets = containsRelationFilter(filter) ? await this._relationSets(filter) : void 0;
 		const state = this._peekState();
 		if (!state) return {
 			matchedCount: 0,
 			modifiedCount: 0
 		};
-		const matched = this._selectForWrite(state, filter, void 0, true);
+		const matched = this._selectForWrite(state, filter, void 0, true, sets);
 		for (const { key, row } of matched) this._commitUpdate(state, key, row, data);
 		return {
 			matchedCount: matched.length,
@@ -1146,9 +1431,10 @@ var MemoryAdapter = class extends BaseDbAdapter {
 	}
 	async deleteMany(filter) {
 		this._assertWritable();
+		const sets = containsRelationFilter(filter) ? await this._relationSets(filter) : void 0;
 		const state = this._peekState();
 		if (!state) return { deletedCount: 0 };
-		const matched = this._selectForWrite(state, filter, void 0, true);
+		const matched = this._selectForWrite(state, filter, void 0, true, sets);
 		for (const { key } of matched) state.rows.delete(key);
 		return { deletedCount: matched.length };
 	}
@@ -1231,6 +1517,10 @@ function setMemoryProvider(space, type, fn) {
 	if (!(adapter instanceof MemoryAdapter)) throw new Error("setMemoryProvider: table is not backed by MemoryAdapter");
 	adapter.setProvider(fn);
 }
+/** @internal Drops the in-memory database of a closed space (called from `createAdapter`'s `onClose`). */
+function clearMemoryDatabase(space) {
+	databases.get(space)?.clear();
+}
 //#endregion
 //#region src/lib/index.ts
 /**
@@ -1243,7 +1533,8 @@ function setMemoryProvider(space, type, fn) {
 * adapter has been built.
 */
 function createAdapter() {
-	return new DbSpace(() => new MemoryAdapter());
+	const space = new DbSpace(() => new MemoryAdapter(), { onClose: () => clearMemoryDatabase(space) });
+	return space;
 }
 //#endregion
 export { MemoryAdapter, buildMemoryPredicate, createAdapter, projectRow, setMemoryProvider, sortRows };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atscript/db-memory",
-  "version": "0.1.146",
+  "version": "0.1.148",
   "description": "In-memory adapter for atscript-db.",
   "keywords": [
     "atscript",
@@ -36,16 +36,16 @@
     "access": "public"
   },
   "devDependencies": {
-    "@atscript/core": "^0.1.98",
-    "@atscript/typescript": "^0.1.98",
-    "@uniqu/core": "^0.1.11",
-    "unplugin-atscript": "^0.1.98"
+    "@atscript/core": "^0.1.100",
+    "@atscript/typescript": "^0.1.100",
+    "@uniqu/core": "^0.1.13",
+    "unplugin-atscript": "^0.1.100"
   },
   "peerDependencies": {
-    "@atscript/core": "^0.1.98",
-    "@atscript/typescript": "^0.1.98",
-    "@uniqu/core": "^0.1.11",
-    "@atscript/db": "^0.1.146"
+    "@atscript/core": "^0.1.100",
+    "@atscript/typescript": "^0.1.100",
+    "@uniqu/core": "^0.1.13",
+    "@atscript/db": "^0.1.148"
   },
   "scripts": {
     "postinstall": "asc -f dts",