kitcn 0.18.0 → 0.20.0

package/dist/{query-context-CJE_hYA3.js → query-context-BzihIpnM.js}

@@ -528,11 +528,19 @@ function getIndexFields(table, index, schema) {
 	fields.push("_id");
 	return fields;
 }
-function getIndexKey(doc, indexFields) {
+/**
+* Read the index key out of a document.
+*
+* Takes field paths already split on `.` rather than the field names: the field
+* list is fixed for the life of a query, so splitting it once at `withIndex`
+* time saves an array allocation per field per document pulled through the
+* stream.
+*/
+function getIndexKey(doc, indexFieldPaths) {
 	const key = [];
-	for (const field of indexFields) {
+	for (const path of indexFieldPaths) {
 		let obj = doc;
-		for (const subfield of field.split(".")) obj = obj[subfield];
+		for (const subfield of path) obj = obj[subfield];
 		key.push(obj);
 	}
 	return key;
@@ -729,17 +737,26 @@ var QueryStream = class {
 	}
 	[Symbol.asyncIterator]() {
 		const iterator = this.iterWithKeys()[Symbol.asyncIterator]();
-		return { async next() {
-			const result = await iterator.next();
-			if (result.done) return {
-				done: true,
-				value: void 0
-			};
-			return {
-				done: false,
-				value: result.value[0]
-			};
-		} };
+		return {
+			async next() {
+				const result = await iterator.next();
+				if (result.done) return {
+					done: true,
+					value: void 0
+				};
+				return {
+					done: false,
+					value: result.value[0]
+				};
+			},
+			async return() {
+				await iterator.return?.();
+				return {
+					done: true,
+					value: void 0
+				};
+			}
+		};
 	}
 };
 var StreamDatabaseReader = class {
@@ -858,6 +875,7 @@ var OrderedStreamQuery = class extends StreamableQuery {
 			table: this.parent.parent.table,
 			index: this.parent.index,
 			indexFields: this.parent.q.indexFields,
+			indexFieldPaths: this.parent.q.indexFieldPaths,
 			order: this.order,
 			bounds: {
 				lowerBound: this.parent.q.lowerBoundIndexKey ?? [],
@@ -876,7 +894,7 @@ var OrderedStreamQuery = class extends StreamableQuery {
 		return db.query(table).withIndex(index, indexRange).order(order);
 	}
 	iterWithKeys() {
-		const { indexFields } = this.reflect();
+		const { indexFieldPaths } = this.reflect();
 		const iterable = this.inner();
 		return { [Symbol.asyncIterator]() {
 			const iterator = iterable[Symbol.asyncIterator]();
@@ -888,7 +906,7 @@ var OrderedStreamQuery = class extends StreamableQuery {
 				};
 				return {
 					done: false,
-					value: [result.value, getIndexKey(result.value, indexFields)]
+					value: [result.value, getIndexKey(result.value, indexFieldPaths)]
 				};
 			} };
 		} };
@@ -950,8 +968,11 @@ var ReflectIndexRange = class {
 	upperBoundInclusive = true;
 	equalityIndexFilter = [];
 	indexFields;
+	/** `indexFields`, each split on `.` once, for `getIndexKey`. */
+	indexFieldPaths;
 	constructor(indexFields) {
 		this.indexFields = indexFields;
+		this.indexFieldPaths = indexFields.map((field) => field.split("."));
 	}
 	eq(field, value) {
 		if (!this.#canLowerBound(field) || !this.#canUpperBound(field)) throw new Error(`Cannot use eq on field '${field}'`);
@@ -1043,16 +1064,24 @@ var ReflectIndexRange = class {
 function mergedStream(streams, orderByIndexFields) {
 	return new MergedStream(streams, orderByIndexFields);
 }
+/**
+* Marks sources that are already `OrderByStream`s, so `narrow` reuses them
+* instead of adding a redundant delegation layer per call.
+*
+* Module-private on purpose: wrapping is also where the ordering invariant is
+* checked, so no caller outside this file can skip it.
+*/
+const PRE_ORDERED_STREAMS = Symbol("preOrderedStreams");
 var MergedStream = class MergedStream extends QueryStream {
 	#order;
 	#streams;
 	#equalityIndexFilter;
 	#indexFields;
-	constructor(streams, orderByIndexFields) {
+	constructor(streams, orderByIndexFields, preOrdered) {
 		super();
 		if (streams.length === 0) throw new Error("Cannot union empty array of streams");
 		this.#order = allSame(streams.map((stream) => stream.getOrder()), "Cannot merge streams with different orders");
-		this.#streams = streams.map((stream) => new OrderByStream(stream, orderByIndexFields));
+		this.#streams = preOrdered === PRE_ORDERED_STREAMS ? streams : streams.map((stream) => new OrderByStream(stream, orderByIndexFields.slice()));
 		this.#indexFields = allSame(this.#streams.map((stream) => stream.getIndexFields()), "Cannot merge streams with different index fields. Consider using .orderBy()");
 		this.#equalityIndexFilter = commonPrefix(this.#streams.map((stream) => stream.getEqualityIndexFilter()));
 	}
@@ -1065,40 +1094,60 @@ var MergedStream = class MergedStream extends QueryStream {
 				done: false,
 				value: void 0
 			}));
-			return { async next() {
-				await Promise.all(iterators.map(async (iterator, i) => {
-					if (!results[i].done && !results[i].value) results[i] = await iterator.next();
-				}));
-				let minIndexKeyAndIndex;
-				for (let i = 0; i < results.length; i++) {
-					const result = results[i];
-					if (result.done || !result.value) continue;
-					const [_, resultIndexKey] = result.value;
-					if (minIndexKeyAndIndex === void 0) {
-						minIndexKeyAndIndex = [resultIndexKey, i];
-						continue;
+			let started = false;
+			let refillIndex;
+			return {
+				async next() {
+					if (started) {
+						if (refillIndex !== void 0) {
+							results[refillIndex] = await iterators[refillIndex].next();
+							refillIndex = void 0;
+						}
+					} else {
+						started = true;
+						await Promise.all(iterators.map(async (iterator, i) => {
+							results[i] = await iterator.next();
+						}));
 					}
-					const [prevMin, _prevMinIndex] = minIndexKeyAndIndex;
-					if (compareKeys({
-						value: resultIndexKey,
-						kind: "exact"
-					}, {
-						value: prevMin,
-						kind: "exact"
-					}) * comparisonInversion < 0) minIndexKeyAndIndex = [resultIndexKey, i];
+					let minIndexKeyAndIndex;
+					for (let i = 0; i < results.length; i++) {
+						const result = results[i];
+						if (result.done || !result.value) continue;
+						const [_, resultIndexKey] = result.value;
+						if (minIndexKeyAndIndex === void 0) {
+							minIndexKeyAndIndex = [resultIndexKey, i];
+							continue;
+						}
+						const [prevMin, _prevMinIndex] = minIndexKeyAndIndex;
+						if (compareKeys({
+							value: resultIndexKey,
+							kind: "exact"
+						}, {
+							value: prevMin,
+							kind: "exact"
+						}) * comparisonInversion < 0) minIndexKeyAndIndex = [resultIndexKey, i];
+					}
+					if (minIndexKeyAndIndex === void 0) return {
+						done: true,
+						value: void 0
+					};
+					const [_, minIndex] = minIndexKeyAndIndex;
+					const result = results[minIndex].value;
+					results[minIndex].value = void 0;
+					refillIndex = minIndex;
+					return {
+						done: false,
+						value: result
+					};
+				},
+				async return() {
+					await Promise.all(iterators.map((iterator) => iterator.return?.()));
+					return {
+						done: true,
+						value: void 0
+					};
 				}
-				if (minIndexKeyAndIndex === void 0) return {
-					done: true,
-					value: void 0
-				};
-				const [_, minIndex] = minIndexKeyAndIndex;
-				const result = results[minIndex].value;
-				results[minIndex].value = void 0;
-				return {
-					done: false,
-					value: result
-				};
-			} };
+			};
 		} };
 	}
 	getOrder() {
@@ -1111,7 +1160,7 @@ var MergedStream = class MergedStream extends QueryStream {
 		return this.#indexFields;
 	}
 	narrow(indexBounds) {
-		return new MergedStream(this.#streams.map((stream) => stream.narrow(indexBounds)), this.#indexFields);
+		return new MergedStream(this.#streams.map((stream) => stream.narrow(indexBounds)), this.#indexFields, PRE_ORDERED_STREAMS);
 	}
 };
 function allSame(values, errorMessage) {
@@ -1159,16 +1208,22 @@ var ConcatStreams = class ConcatStreams extends QueryStream {
 		this.#equalityIndexFilter = commonPrefix(streams.map((stream) => stream.getEqualityIndexFilter()));
 	}
 	iterWithKeys() {
-		const iterables = this.#streams.map((stream) => stream.iterWithKeys());
+		const streams = this.#streams;
 		const comparisonInversion = this.#order === "asc" ? 1 : -1;
-		let previousIndexKey;
 		return { [Symbol.asyncIterator]() {
-			const iterators = iterables.map((iterable) => iterable[Symbol.asyncIterator]());
-			return { async next() {
-				while (iterators.length > 0) {
-					const result = await iterators[0].next();
-					if (result.done) iterators.shift();
-					else {
+			let index = 0;
+			let iterator;
+			let previousIndexKey;
+			return {
+				async next() {
+					while (index < streams.length) {
+						iterator ??= streams[index].iterWithKeys()[Symbol.asyncIterator]();
+						const result = await iterator.next();
+						if (result.done) {
+							index++;
+							iterator = void 0;
+							continue;
+						}
 						const [_, indexKey] = result.value;
 						if (previousIndexKey !== void 0 && compareKeys({
 							value: previousIndexKey,
@@ -1180,12 +1235,21 @@ var ConcatStreams = class ConcatStreams extends QueryStream {
 						previousIndexKey = indexKey;
 						return result;
 					}
+					return {
+						done: true,
+						value: void 0
+					};
+				},
+				async return() {
+					await iterator?.return?.();
+					index = streams.length;
+					iterator = void 0;
+					return {
+						done: true,
+						value: void 0
+					};
 				}
-				return {
-					done: true,
-					value: void 0
-				};
-			} };
+			};
 		} };
 	}
 	getOrder() {
@@ -1258,6 +1322,18 @@ var FlatMapStreamIterator = class {
 			value: [u, [...this.#currentOuterItem.indexKey, ...indexKey]]
 		};
 	}
+	async return() {
+		try {
+			await this.#currentOuterItem?.innerIterator.return?.();
+		} finally {
+			this.#currentOuterItem = null;
+			await this.#outerIterator.return?.();
+		}
+		return {
+			done: true,
+			value: void 0
+		};
+	}
 };
 var FlatMapStream = class FlatMapStream extends QueryStream {
 	#stream;
@@ -1477,15 +1553,24 @@ var OrderByStream = class OrderByStream extends QueryStream {
 		const staticFilter = this.#staticFilter;
 		return { [Symbol.asyncIterator]() {
 			const iterator = iterable[Symbol.asyncIterator]();
-			return { async next() {
-				const result = await iterator.next();
-				if (result.done) return result;
-				const [doc, indexKey] = result.value;
-				return {
-					done: false,
-					value: [doc, indexKey.slice(staticFilter.length)]
-				};
-			} };
+			return {
+				async next() {
+					const result = await iterator.next();
+					if (result.done) return result;
+					const [doc, indexKey] = result.value;
+					return {
+						done: false,
+						value: [doc, indexKey.slice(staticFilter.length)]
+					};
+				},
+				async return() {
+					await iterator.return?.();
+					return {
+						done: true,
+						value: void 0
+					};
+				}
+			};
 		} };
 	}
 	narrow(indexBounds) {
@@ -1516,36 +1601,57 @@ var DistinctStream = class DistinctStream extends QueryStream {
 	iterWithKeys() {
 		const stream = this.#stream;
 		const distinctIndexFieldsLength = this.#distinctIndexFieldsLength;
+		const order = stream.getOrder();
+		const comparisonInversion = order === "asc" ? 1 : -1;
 		return { [Symbol.asyncIterator]() {
-			let currentStream = stream;
-			let currentIterator = currentStream.iterWithKeys()[Symbol.asyncIterator]();
-			return { async next() {
-				const result = await currentIterator.next();
-				if (result.done) return {
-					done: true,
-					value: void 0
-				};
-				const [doc, indexKey] = result.value;
-				if (doc === null) return {
-					done: false,
-					value: [null, indexKey]
-				};
-				const distinctIndexKey = indexKey.slice(0, distinctIndexFieldsLength);
-				if (stream.getOrder() === "asc") currentStream = currentStream.narrow({
-					lowerBound: distinctIndexKey,
-					lowerBoundInclusive: false,
-					upperBound: [],
-					upperBoundInclusive: true
-				});
-				else currentStream = currentStream.narrow({
-					lowerBound: [],
-					lowerBoundInclusive: true,
-					upperBound: distinctIndexKey,
-					upperBoundInclusive: false
-				});
-				currentIterator = currentStream.iterWithKeys()[Symbol.asyncIterator]();
-				return result;
-			} };
+			let currentIterator = stream.iterWithKeys()[Symbol.asyncIterator]();
+			let previousDistinctIndexKey;
+			return {
+				async next() {
+					const result = await currentIterator.next();
+					if (result.done) return {
+						done: true,
+						value: void 0
+					};
+					const [doc, indexKey] = result.value;
+					if (doc === null) return {
+						done: false,
+						value: [null, indexKey]
+					};
+					const distinctIndexKey = indexKey.slice(0, distinctIndexFieldsLength);
+					if (previousDistinctIndexKey !== void 0 && compareKeys({
+						value: previousDistinctIndexKey,
+						kind: "exact"
+					}, {
+						value: distinctIndexKey,
+						kind: "exact"
+					}) * comparisonInversion >= 0) throw new Error(`DistinctStream in wrong order: ${JSON.stringify(previousDistinctIndexKey)}, ${JSON.stringify(distinctIndexKey)}`);
+					previousDistinctIndexKey = distinctIndexKey;
+					let narrowed;
+					if (order === "asc") narrowed = stream.narrow({
+						lowerBound: distinctIndexKey,
+						lowerBoundInclusive: false,
+						upperBound: [],
+						upperBoundInclusive: true
+					});
+					else narrowed = stream.narrow({
+						lowerBound: [],
+						lowerBoundInclusive: true,
+						upperBound: distinctIndexKey,
+						upperBoundInclusive: false
+					});
+					await currentIterator.return?.();
+					currentIterator = narrowed.iterWithKeys()[Symbol.asyncIterator]();
+					return result;
+				},
+				async return() {
+					await currentIterator.return?.();
+					return {
+						done: true,
+						value: void 0
+					};
+				}
+			};
 		} };
 	}
 	narrow(indexBounds) {

package/dist/{runtime-DmVSOe24.js → runtime-6DJxpDfb.js}

@@ -1512,7 +1512,7 @@ function aggregateNameFromNamespace(namespace) {
 async function insertHandler(ctx, args) {
 	const tree = await getOrCreateTree(ctx.db, args.namespace, DEFAULT_MAX_NODE_SIZE, true);
 	const summand = args.summand ?? 0;
-	const pushUp = await insertIntoNode(ctx, args.namespace, tree.root, {
+	const pushUp = await insertIntoNode(ctx, tree.maxNodeSize, tree.root, {
 		k: args.key,
 		v: args.value,
 		s: summand
@@ -1529,7 +1529,7 @@ async function insertHandler(ctx, args) {
 }
 async function deleteHandler(ctx, args) {
 	const tree = await getOrCreateTree(ctx.db, args.namespace, DEFAULT_MAX_NODE_SIZE, true);
-	await deleteFromNode(ctx, args.namespace, tree.root, args.key);
+	await deleteFromNode(ctx, tree.maxNodeSize, tree.root, args.key);
 	const root = await ctx.db.get(tree.root);
 	if (root.items.length === 0 && root.subtrees.length === 1) {
 		log(`collapsing root ${root._id} because its only child is ${root.subtrees[0]}`);
@@ -1538,13 +1538,12 @@ async function deleteHandler(ctx, args) {
 		await ctx.db.delete(root._id);
 	}
 }
-async function MAX_NODE_SIZE(ctx, namespace) {
-	return (await mustGetTree(ctx.db, namespace)).maxNodeSize;
+function assertMaxNodeSize(maxNodeSize) {
+	if (maxNodeSize % 2 !== 0 || maxNodeSize < 4) throw new Error("MAX_NODE_SIZE must be even and at least 4");
 }
-async function MIN_NODE_SIZE(ctx, namespace) {
-	const max = await MAX_NODE_SIZE(ctx, namespace);
-	if (max % 2 !== 0 || max < 4) throw new Error("MAX_NODE_SIZE must be even and at least 4");
-	return max / 2;
+function minNodeSizeFor(maxNodeSize) {
+	assertMaxNodeSize(maxNodeSize);
+	return maxNodeSize / 2;
 }
 async function aggregateBetweenHandler(ctx, args) {
 	const tree = await getTree(ctx.db, args.namespace);
@@ -1554,8 +1553,8 @@ async function aggregateBetweenHandler(ctx, args) {
 	};
 	return await aggregateBetweenInNode(ctx.db, tree.root, args.k1, args.k2);
 }
-async function filterBetween(db, node, k1, k2) {
-	const n = await db.get(node);
+async function filterBetween(db, node, k1, k2, preloaded) {
+	const n = preloaded ?? await db.get(node);
 	const included = [];
 	function includeSubtree(i, unboundedRight) {
 		const unboundedLeft = k1 === void 0 || included.length > 0;
@@ -1623,7 +1622,7 @@ async function offsetUntilHandler(ctx, args) {
 		namespace: args.namespace
 	})).count;
 }
-async function deleteFromNode(ctx, namespace, node, key) {
+async function deleteFromNode(ctx, maxNodeSize, node, key) {
 	let n = await ctx.db.get(node);
 	let foundItem = null;
 	let i = 0;
@@ -1659,13 +1658,13 @@ async function deleteFromNode(ctx, namespace, node, key) {
 		code: "DELETE_MISSING_KEY",
 		message: `key ${p(key)} not found in node ${n._id}`
 	});
-	const deleted = await deleteFromNode(ctx, namespace, n.subtrees[i], key);
+	const deleted = await deleteFromNode(ctx, maxNodeSize, n.subtrees[i], key);
 	if (!deleted) return null;
 	if (!foundItem) foundItem = deleted;
 	const newAggregate = n.aggregate && sub(n.aggregate, itemAggregate(deleted));
 	if (newAggregate) await ctx.db.patch(node, { aggregate: newAggregate });
 	const deficientSubtree = await ctx.db.get(n.subtrees[i]);
-	const minNodeSize = await MIN_NODE_SIZE(ctx, namespace);
+	const minNodeSize = minNodeSizeFor(maxNodeSize);
 	if (deficientSubtree.items.length < minNodeSize) {
 		log(`deficient subtree ${deficientSubtree._id}`);
 		if (i > 0) {
@@ -1751,26 +1750,28 @@ async function mergeNodes(db, parent, leftIndex) {
 	});
 	await db.delete(right._id);
 }
-async function negativeOffsetInNode(db, node, index, k1, k2) {
-	const filtered = await filterBetween(db, node, k1, k2);
+async function negativeOffsetInNode(db, node, index, k1, k2, preloaded) {
+	const filtered = await filterBetween(db, node, k1, k2, preloaded);
 	for (const included of filtered.reverse()) if (included.type === "item") {
 		if (index === 0) return included.item;
 		index -= 1;
 	} else {
-		const subtreeCount = (await nodeAggregate(db, await db.get(included.subtree))).count;
-		if (index < subtreeCount) return await negativeOffsetInNode(db, included.subtree, index);
+		const subtree = await db.get(included.subtree);
+		const subtreeCount = (await nodeAggregate(db, subtree)).count;
+		if (index < subtreeCount) return await negativeOffsetInNode(db, included.subtree, index, void 0, void 0, subtree);
 		index -= subtreeCount;
 	}
 	throw new ConvexError(`negative offset exceeded count by ${index} (in node ${node})`);
 }
-async function atOffsetInNode(db, node, index, k1, k2) {
-	const filtered = await filterBetween(db, node, k1, k2);
+async function atOffsetInNode(db, node, index, k1, k2, preloaded) {
+	const filtered = await filterBetween(db, node, k1, k2, preloaded);
 	for (const included of filtered) if (included.type === "item") {
 		if (index === 0) return included.item;
 		index -= 1;
 	} else {
-		const subtreeCount = (await nodeAggregate(db, await db.get(included.subtree))).count;
-		if (index < subtreeCount) return await atOffsetInNode(db, included.subtree, index);
+		const subtree = await db.get(included.subtree);
+		const subtreeCount = (await nodeAggregate(db, subtree)).count;
+		if (index < subtreeCount) return await atOffsetInNode(db, included.subtree, index, void 0, void 0, subtree);
 		index -= subtreeCount;
 	}
 	throw new ConvexError(`offset exceeded count by ${index} (in node ${node})`);
@@ -1812,7 +1813,7 @@ function accumulate(nums) {
 		sum: 0
 	});
 }
-async function insertIntoNode(ctx, namespace, node, item) {
+async function insertIntoNode(ctx, maxNodeSize, node, item) {
 	const n = await ctx.db.get(node);
 	let i = 0;
 	for (; i < n.items.length; i++) {
@@ -1820,31 +1821,41 @@ async function insertIntoNode(ctx, namespace, node, item) {
 		if (compare === -1) break;
 		if (compare === 0) throw new ConvexError(`key ${p(item.k)} already exists in node ${n._id}`);
 	}
+	let nextItems = n.items;
+	let nextSubtrees = n.subtrees;
 	if (n.subtrees.length > 0) {
-		const pushUp = await insertIntoNode(ctx, namespace, n.subtrees[i], item);
-		if (pushUp) await ctx.db.patch(node, {
-			items: [
+		const pushUp = await insertIntoNode(ctx, maxNodeSize, n.subtrees[i], item);
+		if (pushUp) {
+			nextItems = [
 				...n.items.slice(0, i),
 				pushUp.item,
 				...n.items.slice(i)
-			],
-			subtrees: [
+			];
+			nextSubtrees = [
 				...n.subtrees.slice(0, i),
 				pushUp.leftSubtree,
 				pushUp.rightSubtree,
 				...n.subtrees.slice(i + 1)
-			]
-		});
-	} else await ctx.db.patch(node, { items: [
+			];
+		}
+	} else nextItems = [
 		...n.items.slice(0, i),
 		item,
 		...n.items.slice(i)
-	] });
+	];
 	const newAggregate = n.aggregate && add(n.aggregate, itemAggregate(item));
-	if (newAggregate) await ctx.db.patch(node, { aggregate: newAggregate });
-	const newN = await ctx.db.get(node);
-	const maxNodeSize = await MAX_NODE_SIZE(ctx, namespace);
-	const minNodeSize = await MIN_NODE_SIZE(ctx, namespace);
+	const nodePatch = {};
+	if (nextItems !== n.items) nodePatch.items = nextItems;
+	if (nextSubtrees !== n.subtrees) nodePatch.subtrees = nextSubtrees;
+	if (newAggregate) nodePatch.aggregate = newAggregate;
+	if (Object.keys(nodePatch).length > 0) await ctx.db.patch(node, nodePatch);
+	const newN = {
+		...n,
+		items: nextItems,
+		subtrees: nextSubtrees,
+		aggregate: newAggregate ?? n.aggregate
+	};
+	const minNodeSize = minNodeSizeFor(maxNodeSize);
 	if (newN.items.length > maxNodeSize) {
 		if (newN.items.length !== maxNodeSize + 1 || newN.items.length !== 2 * minNodeSize + 1) throw new Error(`bad ${newN.items.length}`);
 		log(`splitting node ${newN._id} at ${newN.items[minNodeSize].k}`);
@@ -1889,6 +1900,7 @@ async function getOrCreateTree(db, namespace, maxNodeSize, rootLazy) {
 	const originalTree = await getTree(db, namespace);
 	const aggregateName = aggregateNameFromNamespace(namespace);
 	if (originalTree) {
+		assertMaxNodeSize(originalTree.maxNodeSize);
 		if (originalTree.aggregateName !== aggregateName) {
 			await db.patch(originalTree._id, { aggregateName });
 			return {
@@ -1906,7 +1918,7 @@ async function getOrCreateTree(db, namespace, maxNodeSize, rootLazy) {
 			sum: 0
 		}
 	});
-	const effectiveMaxNodeSize = maxNodeSize ?? await MAX_NODE_SIZE({ db }, void 0) ?? DEFAULT_MAX_NODE_SIZE;
+	const effectiveMaxNodeSize = maxNodeSize ?? (await mustGetTree(db, void 0)).maxNodeSize;
 	const effectiveRootLazy = rootLazy ?? await isRootLazy(db, void 0) ?? true;
 	const id = await db.insert(AGGREGATE_TREE_TABLE, {
 		aggregateName,
@@ -1915,7 +1927,7 @@ async function getOrCreateTree(db, namespace, maxNodeSize, rootLazy) {
 		namespace
 	});
 	const newTree = await db.get(id);
-	await MIN_NODE_SIZE({ db }, namespace);
+	assertMaxNodeSize(effectiveMaxNodeSize);
 	if (effectiveRootLazy) await db.patch(root, { aggregate: void 0 });
 	return newTree;
 }
@@ -1930,6 +1942,19 @@ async function deleteTreeNodes(db, node) {
 	for (const subtree of current.subtrees) await deleteTreeNodes(db, subtree);
 	await db.delete(node);
 }
+/**
+* Deletes up to `limit` namespace trees belonging to one aggregate, returning
+* true once none are left. Unlike `clearTree` this does not recreate the tree,
+* so a caller can drain every namespace across several transactions.
+*/
+async function deleteTreesHandler(ctx, args) {
+	const trees = await ctx.db.query(AGGREGATE_TREE_TABLE).withIndex("by_aggregate_name", (q) => q.eq("aggregateName", args.aggregateName)).take(args.limit);
+	for (const tree of trees) {
+		await deleteTreeNodes(ctx.db, tree.root);
+		await ctx.db.delete(tree._id);
+	}
+	return trees.length === 0;
+}
 async function clearTree(db, args) {
 	const tree = await getTree(db, args.namespace);
 	let existingRootLazy = true;
@@ -2319,6 +2344,17 @@ var Aggregate = class {
 			rootLazy: opts[0]?.rootLazy
 		});
 	}
+	/**
+	* Deletes up to `limit` namespace trees without recreating them. Returns true
+	* once this aggregate owns no trees, so callers can drain every namespace
+	* across several mutations instead of walking them all in one.
+	*/
+	async deleteTrees(ctx, limit) {
+		return deleteTreesHandler({ db: ctx.db }, {
+			aggregateName: this.aggregateName,
+			limit
+		});
+	}
 	async makeRootLazy(ctx, namespace) {
 		const tree = await getOrCreateTree(ctx.db, namespaceForArg(this.aggregateName, { namespace }));
 		await ctx.db.patch(tree.root, { aggregate: void 0 });

package/dist/watcher.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { a as generateMeta, c as PARSE_SNAPSHOT_SUFFIX, i as resolveConfiguredBackend, n as withLocalCodegenEnv, o as getConvexConfig, r as loadCliConfig, s as logger } from "./local-env-DykABjCt.mjs";
+import { a as generateMeta, c as PARSE_SNAPSHOT_SUFFIX, i as resolveConfiguredBackend, n as withLocalCodegenEnv, o as getConvexConfig, r as loadCliConfig, s as logger } from "./local-env-yFKub75x.mjs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";