better-convex 0.7.2 → 0.8.0

package/dist/runtime-C0WcYGY0.js

@@ -0,0 +1,1028 @@
+import { C as integer, g as index, t as convexTable, x as text } from "./table-B7yzBihE.js";
+import { r as custom, t as id } from "./id-BcBb900m.js";
+import { ConvexError, convexToJson, jsonToConvex, v } from "convex/values";
+
+//#region src/aggregate-core/compare.ts
+function compareValues$1(k1, k2) {
+	return compareAsTuples(makeComparable(k1), makeComparable(k2));
+}
+function compareAsTuples(a, b) {
+	if (a[0] === b[0]) return compareSameTypeValues(a[1], b[1]);
+	if (a[0] < b[0]) return -1;
+	return 1;
+}
+function compareSameTypeValues(v1, v2) {
+	if (v1 === void 0 || v1 === null) return 0;
+	if (typeof v1 === "bigint" || typeof v1 === "number" || typeof v1 === "boolean" || typeof v1 === "string") return v1 < v2 ? -1 : v1 === v2 ? 0 : 1;
+	if (!Array.isArray(v1) || !Array.isArray(v2)) throw new Error(`Unexpected type ${v1}`);
+	for (let i = 0; i < v1.length && i < v2.length; i++) {
+		const cmp = compareAsTuples(v1[i], v2[i]);
+		if (cmp !== 0) return cmp;
+	}
+	if (v1.length < v2.length) return -1;
+	if (v1.length > v2.length) return 1;
+	return 0;
+}
+function makeComparable(v) {
+	if (v === void 0) return [0, void 0];
+	if (v === null) return [1, null];
+	if (typeof v === "bigint") return [2, v];
+	if (typeof v === "number") {
+		if (Number.isNaN(v)) return [3.5, 0];
+		return [3, v];
+	}
+	if (typeof v === "boolean") return [4, v];
+	if (typeof v === "string") return [5, v];
+	if (v instanceof ArrayBuffer) return [6, Array.from(new Uint8Array(v)).map(makeComparable)];
+	if (Array.isArray(v)) return [7, v.map(makeComparable)];
+	return [8, Object.keys(v).sort().map((k) => [k, v[k]]).map(makeComparable)];
+}
+
+//#endregion
+//#region src/aggregate-core/schema.ts
+const AGGREGATE_TREE_TABLE = "aggregate_rank_tree";
+const AGGREGATE_NODE_TABLE = "aggregate_rank_node";
+const aggregateCounterValidator = v.object({
+	count: v.number(),
+	sum: v.number()
+});
+const aggregateItemValidator = v.object({
+	k: v.any(),
+	v: v.any(),
+	s: v.number()
+});
+const aggregateTreeTable = convexTable(AGGREGATE_TREE_TABLE, {
+	aggregateName: text().notNull(),
+	maxNodeSize: integer().notNull(),
+	namespace: custom(v.any()),
+	root: id(AGGREGATE_NODE_TABLE).notNull()
+}, (tree) => [index("by_namespace").on(tree.namespace), index("by_aggregate_name").on(tree.aggregateName)]);
+const aggregateNodeTable = convexTable(AGGREGATE_NODE_TABLE, {
+	aggregate: custom(aggregateCounterValidator),
+	items: custom(v.array(aggregateItemValidator)).notNull(),
+	subtrees: custom(v.array(v.string())).notNull()
+});
+const aggregateStorageTables = {
+	[AGGREGATE_NODE_TABLE]: aggregateNodeTable,
+	[AGGREGATE_TREE_TABLE]: aggregateTreeTable
+};
+
+//#endregion
+//#region src/aggregate-core/btree.ts
+const DEFAULT_MAX_NODE_SIZE = 16;
+const LEGACY_AGGREGATE_NAME = "__legacy__";
+function p(v) {
+	try {
+		return JSON.stringify(v);
+	} catch {
+		return String(v);
+	}
+}
+function log(s) {}
+function aggregateNameFromNamespace(namespace) {
+	if (Array.isArray(namespace) && namespace.length === 3 && typeof namespace[0] === "string" && (namespace[2] === 0 || namespace[2] === 1)) return namespace[0];
+	return LEGACY_AGGREGATE_NAME;
+}
+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, {
+		k: args.key,
+		v: args.value,
+		s: summand
+	});
+	if (pushUp) {
+		const total = pushUp.leftSubtreeCount && pushUp.rightSubtreeCount && add(add(pushUp.leftSubtreeCount, pushUp.rightSubtreeCount), itemAggregate(pushUp.item));
+		const newRoot = await ctx.db.insert(AGGREGATE_NODE_TABLE, {
+			items: [pushUp.item],
+			subtrees: [pushUp.leftSubtree, pushUp.rightSubtree],
+			aggregate: total
+		});
+		await ctx.db.patch(tree._id, { root: newRoot });
+	}
+}
+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);
+	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]}`);
+		await ctx.db.patch(tree._id, { root: root.subtrees[0] });
+		if (root.aggregate === void 0) await ctx.db.patch(root.subtrees[0], { aggregate: void 0 });
+		await ctx.db.delete(root._id);
+	}
+}
+async function MAX_NODE_SIZE(ctx, namespace) {
+	return (await mustGetTree(ctx.db, namespace)).maxNodeSize;
+}
+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;
+}
+async function aggregateBetweenHandler(ctx, args) {
+	const tree = await getTree(ctx.db, args.namespace);
+	if (tree === null) return {
+		count: 0,
+		sum: 0
+	};
+	return await aggregateBetweenInNode(ctx.db, tree.root, args.k1, args.k2);
+}
+async function filterBetween(db, node, k1, k2) {
+	const n = await db.get(node);
+	const included = [];
+	function includeSubtree(i, unboundedRight) {
+		const unboundedLeft = k1 === void 0 || included.length > 0;
+		if (unboundedLeft && unboundedRight) included.push({
+			type: "subtree",
+			subtree: n.subtrees[i]
+		});
+		else included.push(filterBetween(db, n.subtrees[i], unboundedLeft ? void 0 : k1, unboundedRight ? void 0 : k2));
+	}
+	let done = false;
+	for (let i = 0; i < n.items.length; i++) {
+		const k1IsLeft = k1 === void 0 || compareKeys(k1, n.items[i].k) === -1;
+		const k2IsRight = k2 === void 0 || compareKeys(k2, n.items[i].k) === 1;
+		if (k1IsLeft && n.subtrees.length > 0) includeSubtree(i, k2IsRight);
+		if (!k2IsRight) {
+			done = true;
+			break;
+		}
+		if (k1IsLeft) included.push({
+			type: "item",
+			item: n.items[i]
+		});
+	}
+	if (!done && n.subtrees.length > 0) includeSubtree(n.subtrees.length - 1, k2 === void 0);
+	return (await Promise.all(included)).flat(1);
+}
+async function aggregateBetweenInNode(db, node, k1, k2) {
+	const filtered = await filterBetween(db, node, k1, k2);
+	const counts = await Promise.all(filtered.map(async (included) => {
+		if (included.type === "item") return itemAggregate(included.item);
+		return await nodeAggregate(db, await db.get(included.subtree));
+	}));
+	let count = {
+		count: 0,
+		sum: 0
+	};
+	for (const c of counts) count = add(count, c);
+	return count;
+}
+async function atOffsetHandler(ctx, args) {
+	if (args.offset < 0) throw new Error("offset must be non-negative");
+	if (!Number.isInteger(args.offset)) throw new Error("offset must be an integer");
+	const tree = await getTree(ctx.db, args.namespace);
+	if (tree === null) throw new ConvexError("tree is empty");
+	return await atOffsetInNode(ctx.db, tree.root, args.offset, args.k1, args.k2);
+}
+async function atNegativeOffsetHandler(ctx, args) {
+	if (args.offset < 0) throw new Error("offset must be non-negative");
+	if (!Number.isInteger(args.offset)) throw new Error("offset must be an integer");
+	const tree = await getTree(ctx.db, args.namespace);
+	if (tree === null) throw new ConvexError("tree is empty");
+	return await negativeOffsetInNode(ctx.db, tree.root, args.offset, args.k1, args.k2);
+}
+async function offsetHandler(ctx, args) {
+	return (await aggregateBetweenHandler(ctx, {
+		k1: args.k1,
+		k2: args.key,
+		namespace: args.namespace
+	})).count;
+}
+async function offsetUntilHandler(ctx, args) {
+	return (await aggregateBetweenHandler(ctx, {
+		k1: args.key,
+		k2: args.k2,
+		namespace: args.namespace
+	})).count;
+}
+async function deleteFromNode(ctx, namespace, node, key) {
+	let n = await ctx.db.get(node);
+	let foundItem = null;
+	let i = 0;
+	for (; i < n.items.length; i++) {
+		const compare = compareKeys(key, n.items[i].k);
+		if (compare === -1) break;
+		if (compare === 0) {
+			log(`found key ${p(key)} in node ${n._id}`);
+			if (n.subtrees.length === 0) {
+				await ctx.db.patch(node, {
+					items: [...n.items.slice(0, i), ...n.items.slice(i + 1)],
+					aggregate: n.aggregate && sub(n.aggregate, itemAggregate(n.items[i]))
+				});
+				return n.items[i];
+			}
+			const predecessor = await negativeOffsetInNode(ctx.db, n.subtrees[i], 0);
+			log(`replacing ${p(key)} with predecessor ${p(predecessor.k)}`);
+			foundItem = n.items[i];
+			await ctx.db.patch(node, {
+				items: [
+					...n.items.slice(0, i),
+					predecessor,
+					...n.items.slice(i + 1)
+				],
+				aggregate: n.aggregate && sub(add(n.aggregate, itemAggregate(predecessor)), itemAggregate(n.items[i]))
+			});
+			n = await ctx.db.get(node);
+			key = predecessor.k;
+			break;
+		}
+	}
+	if (n.subtrees.length === 0) throw new ConvexError({
+		code: "DELETE_MISSING_KEY",
+		message: `key ${p(key)} not found in node ${n._id}`
+	});
+	const deleted = await deleteFromNode(ctx, namespace, 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);
+	if (deficientSubtree.items.length < minNodeSize) {
+		log(`deficient subtree ${deficientSubtree._id}`);
+		if (i > 0) {
+			const leftSibling = await ctx.db.get(n.subtrees[i - 1]);
+			if (leftSibling.items.length > minNodeSize) {
+				log(`rotating right with left sibling ${leftSibling._id}`);
+				const grandchild = leftSibling.subtrees.length ? await ctx.db.get(leftSibling.subtrees[leftSibling.subtrees.length - 1]) : null;
+				const grandchildCount = grandchild ? grandchild.aggregate : {
+					count: 0,
+					sum: 0
+				};
+				await ctx.db.patch(deficientSubtree._id, {
+					items: [n.items[i - 1], ...deficientSubtree.items],
+					subtrees: grandchild ? [grandchild._id, ...deficientSubtree.subtrees] : [],
+					aggregate: deficientSubtree.aggregate && grandchildCount && add(add(deficientSubtree.aggregate, grandchildCount), itemAggregate(n.items[i - 1]))
+				});
+				await ctx.db.patch(leftSibling._id, {
+					items: leftSibling.items.slice(0, leftSibling.items.length - 1),
+					subtrees: grandchild ? leftSibling.subtrees.slice(0, leftSibling.subtrees.length - 1) : [],
+					aggregate: leftSibling.aggregate && grandchildCount && sub(sub(leftSibling.aggregate, grandchildCount), itemAggregate(leftSibling.items[leftSibling.items.length - 1]))
+				});
+				await ctx.db.patch(node, { items: [
+					...n.items.slice(0, i - 1),
+					leftSibling.items[leftSibling.items.length - 1],
+					...n.items.slice(i)
+				] });
+				return foundItem;
+			}
+		}
+		if (i < n.subtrees.length - 1) {
+			const rightSibling = await ctx.db.get(n.subtrees[i + 1]);
+			if (rightSibling.items.length > minNodeSize) {
+				log(`rotating left with right sibling ${rightSibling._id}`);
+				const grandchild = rightSibling.subtrees.length ? await ctx.db.get(rightSibling.subtrees[0]) : null;
+				const grandchildCount = grandchild ? grandchild.aggregate : {
+					count: 0,
+					sum: 0
+				};
+				await ctx.db.patch(deficientSubtree._id, {
+					items: [...deficientSubtree.items, n.items[i]],
+					subtrees: grandchild ? [...deficientSubtree.subtrees, grandchild._id] : [],
+					aggregate: deficientSubtree.aggregate && grandchildCount && add(add(deficientSubtree.aggregate, grandchildCount), itemAggregate(n.items[i]))
+				});
+				await ctx.db.patch(rightSibling._id, {
+					items: rightSibling.items.slice(1),
+					subtrees: grandchild ? rightSibling.subtrees.slice(1) : [],
+					aggregate: rightSibling.aggregate && grandchildCount && sub(sub(rightSibling.aggregate, grandchildCount), itemAggregate(rightSibling.items[0]))
+				});
+				await ctx.db.patch(node, { items: [
+					...n.items.slice(0, i),
+					rightSibling.items[0],
+					...n.items.slice(i + 1)
+				] });
+				return foundItem;
+			}
+		}
+		if (i > 0) {
+			log("merging with left sibling");
+			await mergeNodes(ctx.db, n, i - 1);
+		} else {
+			log("merging with right sibling");
+			await mergeNodes(ctx.db, n, i);
+		}
+	}
+	return foundItem;
+}
+async function mergeNodes(db, parent, leftIndex) {
+	const left = await db.get(parent.subtrees[leftIndex]);
+	const right = await db.get(parent.subtrees[leftIndex + 1]);
+	log(`merging ${right._id} into ${left._id}`);
+	await db.patch(left._id, {
+		items: [
+			...left.items,
+			parent.items[leftIndex],
+			...right.items
+		],
+		subtrees: [...left.subtrees, ...right.subtrees],
+		aggregate: left.aggregate && right.aggregate && add(add(left.aggregate, right.aggregate), itemAggregate(parent.items[leftIndex]))
+	});
+	await db.patch(parent._id, {
+		items: [...parent.items.slice(0, leftIndex), ...parent.items.slice(leftIndex + 1)],
+		subtrees: [...parent.subtrees.slice(0, leftIndex + 1), ...parent.subtrees.slice(leftIndex + 2)]
+	});
+	await db.delete(right._id);
+}
+async function negativeOffsetInNode(db, node, index, k1, k2) {
+	const filtered = await filterBetween(db, node, k1, k2);
+	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);
+		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);
+	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);
+		index -= subtreeCount;
+	}
+	throw new ConvexError(`offset exceeded count by ${index} (in node ${node})`);
+}
+function itemAggregate(item) {
+	return {
+		count: 1,
+		sum: item.s
+	};
+}
+function nodeCounts(node) {
+	return node.items.map(itemAggregate);
+}
+async function subtreeCounts(db, node) {
+	return await Promise.all(node.subtrees.map(async (subtree) => {
+		return nodeAggregate(db, await db.get(subtree));
+	}));
+}
+async function nodeAggregate(db, node) {
+	if (node.aggregate !== void 0) return node.aggregate;
+	const subCounts = await subtreeCounts(db, node);
+	return add(accumulate(nodeCounts(node)), accumulate(subCounts));
+}
+function add(a, b) {
+	return {
+		count: a.count + b.count,
+		sum: a.sum + b.sum
+	};
+}
+function sub(a, b) {
+	return {
+		count: a.count - b.count,
+		sum: a.sum - b.sum
+	};
+}
+function accumulate(nums) {
+	return nums.reduce(add, {
+		count: 0,
+		sum: 0
+	});
+}
+async function insertIntoNode(ctx, namespace, node, item) {
+	const n = await ctx.db.get(node);
+	let i = 0;
+	for (; i < n.items.length; i++) {
+		const compare = compareKeys(item.k, n.items[i].k);
+		if (compare === -1) break;
+		if (compare === 0) throw new ConvexError(`key ${p(item.k)} already exists in node ${n._id}`);
+	}
+	if (n.subtrees.length > 0) {
+		const pushUp = await insertIntoNode(ctx, namespace, n.subtrees[i], item);
+		if (pushUp) await ctx.db.patch(node, {
+			items: [
+				...n.items.slice(0, i),
+				pushUp.item,
+				...n.items.slice(i)
+			],
+			subtrees: [
+				...n.subtrees.slice(0, i),
+				pushUp.leftSubtree,
+				pushUp.rightSubtree,
+				...n.subtrees.slice(i + 1)
+			]
+		});
+	} else await ctx.db.patch(node, { items: [
+		...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);
+	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}`);
+		const topLevel = nodeCounts(newN);
+		const subCounts = await subtreeCounts(ctx.db, newN);
+		const leftCount = add(accumulate(topLevel.slice(0, minNodeSize)), accumulate(subCounts.length ? subCounts.slice(0, minNodeSize + 1) : []));
+		const rightCount = add(accumulate(topLevel.slice(minNodeSize + 1)), accumulate(subCounts.length ? subCounts.slice(minNodeSize + 1) : []));
+		if (newN.aggregate && leftCount.count + rightCount.count + 1 !== newN.aggregate.count) throw new Error(`bad count split ${leftCount.count} ${rightCount.count} ${newN.aggregate.count}`);
+		if (newN.aggregate && Math.abs(leftCount.sum + rightCount.sum + newN.items[minNodeSize].s - newN.aggregate.sum) > 1e-5) throw new Error(`bad sum split ${leftCount.sum} ${rightCount.sum} ${newN.items[minNodeSize].s} ${newN.aggregate.sum}`);
+		await ctx.db.patch(node, {
+			items: newN.items.slice(0, minNodeSize),
+			subtrees: newN.subtrees.length ? newN.subtrees.slice(0, minNodeSize + 1) : [],
+			aggregate: leftCount
+		});
+		const splitN = await ctx.db.insert(AGGREGATE_NODE_TABLE, {
+			items: newN.items.slice(minNodeSize + 1),
+			subtrees: newN.subtrees.length ? newN.subtrees.slice(minNodeSize + 1) : [],
+			aggregate: rightCount
+		});
+		return {
+			item: newN.items[minNodeSize],
+			leftSubtree: node,
+			rightSubtree: splitN,
+			leftSubtreeCount: newN.aggregate && leftCount,
+			rightSubtreeCount: newN.aggregate && rightCount
+		};
+	}
+	return null;
+}
+function compareKeys(k1, k2) {
+	return compareValues$1(k1, k2);
+}
+async function getTree(db, namespace) {
+	return await db.query(AGGREGATE_TREE_TABLE).withIndex("by_namespace", (q) => q.eq("namespace", namespace)).unique();
+}
+async function mustGetTree(db, namespace) {
+	const tree = await getTree(db, namespace);
+	if (!tree) throw new Error("btree not initialized");
+	return tree;
+}
+async function getOrCreateTree(db, namespace, maxNodeSize, rootLazy) {
+	const originalTree = await getTree(db, namespace);
+	const aggregateName = aggregateNameFromNamespace(namespace);
+	if (originalTree) {
+		if (originalTree.aggregateName !== aggregateName) {
+			await db.patch(originalTree._id, { aggregateName });
+			return {
+				...originalTree,
+				aggregateName
+			};
+		}
+		return originalTree;
+	}
+	const root = await db.insert(AGGREGATE_NODE_TABLE, {
+		items: [],
+		subtrees: [],
+		aggregate: {
+			count: 0,
+			sum: 0
+		}
+	});
+	const effectiveMaxNodeSize = maxNodeSize ?? await MAX_NODE_SIZE({ db }, void 0) ?? DEFAULT_MAX_NODE_SIZE;
+	const effectiveRootLazy = rootLazy ?? await isRootLazy(db, void 0) ?? true;
+	const id = await db.insert(AGGREGATE_TREE_TABLE, {
+		aggregateName,
+		root,
+		maxNodeSize: effectiveMaxNodeSize,
+		namespace
+	});
+	const newTree = await db.get(id);
+	await MIN_NODE_SIZE({ db }, namespace);
+	if (effectiveRootLazy) await db.patch(root, { aggregate: void 0 });
+	return newTree;
+}
+async function isRootLazy(db, namespace) {
+	const tree = await getTree(db, namespace);
+	if (!tree) return true;
+	return (await db.get(tree.root))?.aggregate === void 0;
+}
+async function deleteTreeNodes(db, node) {
+	const current = await db.get(node);
+	if (!current) return;
+	for (const subtree of current.subtrees) await deleteTreeNodes(db, subtree);
+	await db.delete(node);
+}
+async function clearTree(db, args) {
+	const tree = await getTree(db, args.namespace);
+	let existingRootLazy = true;
+	let existingMaxNodeSize = DEFAULT_MAX_NODE_SIZE;
+	if (tree) {
+		await db.delete(tree._id);
+		const root = await db.get(tree.root);
+		if (root) {
+			existingRootLazy = root.aggregate === void 0;
+			await deleteTreeNodes(db, tree.root);
+		}
+		existingMaxNodeSize = tree.maxNodeSize;
+	}
+	await getOrCreateTree(db, args.namespace, args.maxNodeSize ?? existingMaxNodeSize, args.rootLazy ?? existingRootLazy);
+}
+async function paginateHandler(ctx, args) {
+	const tree = await getTree(ctx.db, args.namespace);
+	if (tree === null) return {
+		page: [],
+		cursor: "",
+		isDone: true
+	};
+	return await paginateInNode(ctx.db, tree.root, args.limit, args.order, args.cursor, args.k1, args.k2);
+}
+async function paginateInNode(db, node, limit, order, cursor, k1, k2) {
+	if (limit <= 0) throw new ConvexError("limit must be positive");
+	if (cursor !== void 0 && cursor.length === 0) return {
+		page: [],
+		cursor: "",
+		isDone: true
+	};
+	const items = [];
+	const filtered = await filterBetween(db, node, cursor === void 0 || order === "desc" ? k1 : jsonToConvex(JSON.parse(cursor)), cursor === void 0 || order === "asc" ? k2 : jsonToConvex(JSON.parse(cursor)));
+	if (order === "desc") filtered.reverse();
+	for (const included of filtered) {
+		if (items.length >= limit) return {
+			page: items,
+			cursor: JSON.stringify(convexToJson(items[items.length - 1].k)),
+			isDone: false
+		};
+		if (included.type === "item") items.push(included.item);
+		else {
+			const { page, cursor: newCursor, isDone } = await paginateInNode(db, included.subtree, limit - items.length, order);
+			items.push(...page);
+			if (!isDone) return {
+				page: items,
+				cursor: newCursor,
+				isDone: false
+			};
+		}
+	}
+	return {
+		page: items,
+		cursor: "",
+		isDone: true
+	};
+}
+async function paginateNamespacesHandler(ctx, args) {
+	if (args.cursor === "endcursor") return {
+		page: [],
+		cursor: "endcursor",
+		isDone: true
+	};
+	const { page: trees, continueCursor, isDone } = await (args.aggregateName === void 0 ? ctx.db.query(AGGREGATE_TREE_TABLE) : ctx.db.query(AGGREGATE_TREE_TABLE).withIndex("by_aggregate_name", (q) => q.eq("aggregateName", args.aggregateName))).paginate({
+		cursor: args.cursor ?? null,
+		numItems: args.limit
+	});
+	return {
+		page: trees.map((t) => t.namespace ?? null),
+		cursor: isDone ? "endcursor" : continueCursor ?? "endcursor",
+		isDone
+	};
+}
+async function aggregateBetweenBatchHandler(ctx, args) {
+	return await Promise.all(args.queries.map((query) => aggregateBetweenHandler(ctx, query)));
+}
+async function atOffsetBatchHandler(ctx, args) {
+	return await Promise.all(args.queries.map((query) => query.offset >= 0 ? atOffsetHandler(ctx, query) : atNegativeOffsetHandler(ctx, {
+		...query,
+		offset: -query.offset - 1
+	})));
+}
+
+//#endregion
+//#region src/aggregate-core/positions.ts
+const BEFORE_ALL_IDS = null;
+const AFTER_ALL_IDS = [];
+function explodeKey(key) {
+	if (Array.isArray(key)) {
+		const exploded = [""];
+		for (const item of key) {
+			exploded.push(item);
+			exploded.push("");
+		}
+		return exploded;
+	}
+	return key;
+}
+function implodeKey(k) {
+	if (Array.isArray(k)) {
+		const imploded = [];
+		for (let i = 1; i < k.length; i += 2) imploded.push(k[i]);
+		return imploded;
+	}
+	return k;
+}
+function keyToPosition(key, id) {
+	return [
+		explodeKey(key),
+		id,
+		""
+	];
+}
+function positionToKey(position) {
+	return {
+		key: implodeKey(position[0]),
+		id: position[1]
+	};
+}
+function boundsToPositions(bounds) {
+	if (bounds === void 0) return {};
+	if ("eq" in bounds) return {
+		k1: boundToPosition("lower", {
+			key: bounds.eq,
+			inclusive: true
+		}),
+		k2: boundToPosition("upper", {
+			key: bounds.eq,
+			inclusive: true
+		})
+	};
+	if ("prefix" in bounds) {
+		const prefix = bounds.prefix;
+		const exploded = [];
+		for (const item of prefix) {
+			exploded.push("");
+			exploded.push(item);
+		}
+		return {
+			k1: [
+				exploded.concat([BEFORE_ALL_IDS]),
+				BEFORE_ALL_IDS,
+				BEFORE_ALL_IDS
+			],
+			k2: [
+				exploded.concat([AFTER_ALL_IDS]),
+				AFTER_ALL_IDS,
+				AFTER_ALL_IDS
+			]
+		};
+	}
+	return {
+		k1: boundToPosition("lower", bounds.lower),
+		k2: boundToPosition("upper", bounds.upper)
+	};
+}
+function boundToPosition(direction, bound) {
+	if (bound === void 0) return;
+	if (direction === "lower") return [
+		explodeKey(bound.key),
+		bound.id ?? (bound.inclusive ? BEFORE_ALL_IDS : AFTER_ALL_IDS),
+		bound.inclusive ? BEFORE_ALL_IDS : AFTER_ALL_IDS
+	];
+	return [
+		explodeKey(bound.key),
+		bound.id ?? (bound.inclusive ? AFTER_ALL_IDS : BEFORE_ALL_IDS),
+		bound.inclusive ? AFTER_ALL_IDS : BEFORE_ALL_IDS
+	];
+}
+
+//#endregion
+//#region src/aggregate-core/runtime.ts
+const INTERNAL_NAMESPACE_MARKER_MISSING = 0;
+const INTERNAL_NAMESPACE_MARKER_PRESENT = 1;
+const encodeNamespace = (aggregateName, namespace) => [
+	aggregateName,
+	namespace === void 0 ? null : namespace,
+	namespace === void 0 ? INTERNAL_NAMESPACE_MARKER_MISSING : INTERNAL_NAMESPACE_MARKER_PRESENT
+];
+const isInternalNamespace = (value) => Array.isArray(value) && value.length === 3 && typeof value[0] === "string" && (value[2] === INTERNAL_NAMESPACE_MARKER_MISSING || value[2] === INTERNAL_NAMESPACE_MARKER_PRESENT);
+const decodeNamespace = (namespace) => {
+	if (namespace[2] === INTERNAL_NAMESPACE_MARKER_MISSING) return;
+	return namespace[1];
+};
+const namespaceForOpts = (aggregateName, opts) => encodeNamespace(aggregateName, namespaceFromOpts(opts));
+const namespaceForArg = (aggregateName, args) => encodeNamespace(aggregateName, namespaceFromArg(args));
+/**
+* Write data to be aggregated, and read aggregated data.
+*/
+var Aggregate = class {
+	constructor(aggregateName) {
+		this.aggregateName = aggregateName;
+	}
+	async count(ctx, ...opts) {
+		return (await aggregateBetweenHandler({ db: ctx.db }, {
+			...boundsToPositions(opts[0]?.bounds),
+			namespace: namespaceForOpts(this.aggregateName, opts)
+		})).count;
+	}
+	async countBatch(ctx, queries) {
+		return (await aggregateBetweenBatchHandler({ db: ctx.db }, { queries: queries.map((query) => {
+			if (!query) throw new Error("You must pass bounds and/or namespace");
+			return {
+				...boundsToPositions(query.bounds),
+				namespace: namespaceForArg(this.aggregateName, query)
+			};
+		}) })).map((result) => result.count);
+	}
+	async sum(ctx, ...opts) {
+		return (await aggregateBetweenHandler({ db: ctx.db }, {
+			...boundsToPositions(opts[0]?.bounds),
+			namespace: namespaceForOpts(this.aggregateName, opts)
+		})).sum;
+	}
+	async sumBatch(ctx, queries) {
+		return (await aggregateBetweenBatchHandler({ db: ctx.db }, { queries: queries.map((query) => {
+			if (!query) throw new Error("You must pass bounds and/or namespace");
+			return {
+				...boundsToPositions(query.bounds),
+				namespace: namespaceForArg(this.aggregateName, query)
+			};
+		}) })).map((result) => result.sum);
+	}
+	async at(ctx, offset, ...opts) {
+		const encodedNamespace = namespaceForOpts(this.aggregateName, opts);
+		return btreeItemToAggregateItem(offset < 0 ? await atNegativeOffsetHandler({ db: ctx.db }, {
+			...boundsToPositions(opts[0]?.bounds),
+			namespace: encodedNamespace,
+			offset: -offset - 1
+		}) : await atOffsetHandler({ db: ctx.db }, {
+			...boundsToPositions(opts[0]?.bounds),
+			namespace: encodedNamespace,
+			offset
+		}));
+	}
+	async atBatch(ctx, queries) {
+		return (await atOffsetBatchHandler({ db: ctx.db }, { queries: queries.map((query) => ({
+			...boundsToPositions(query.bounds),
+			namespace: namespaceForArg(this.aggregateName, query),
+			offset: query.offset
+		})) })).map(btreeItemToAggregateItem);
+	}
+	async indexOf(ctx, key, ...opts) {
+		const { k1, k2 } = boundsToPositions(opts[0]?.bounds);
+		const namespace = namespaceForOpts(this.aggregateName, opts);
+		if (opts[0]?.order === "desc") return offsetUntilHandler({ db: ctx.db }, {
+			k2,
+			key: boundToPosition("upper", {
+				id: opts[0]?.id,
+				inclusive: true,
+				key
+			}),
+			namespace
+		});
+		return offsetHandler({ db: ctx.db }, {
+			k1,
+			key: boundToPosition("lower", {
+				id: opts[0]?.id,
+				inclusive: true,
+				key
+			}),
+			namespace
+		});
+	}
+	async offsetOf(ctx, key, namespace, id, bounds) {
+		return this.indexOf(ctx, key, {
+			bounds,
+			id,
+			namespace,
+			order: "asc"
+		});
+	}
+	async offsetUntil(ctx, key, namespace, id, bounds) {
+		return this.indexOf(ctx, key, {
+			bounds,
+			id,
+			namespace,
+			order: "desc"
+		});
+	}
+	async min(ctx, ...opts) {
+		const { page } = await this.paginate(ctx, {
+			bounds: opts[0]?.bounds,
+			namespace: namespaceFromOpts(opts),
+			order: "asc",
+			pageSize: 1
+		});
+		return page[0] ?? null;
+	}
+	async max(ctx, ...opts) {
+		const { page } = await this.paginate(ctx, {
+			bounds: opts[0]?.bounds,
+			namespace: namespaceFromOpts(opts),
+			order: "desc",
+			pageSize: 1
+		});
+		return page[0] ?? null;
+	}
+	async random(ctx, ...opts) {
+		const count = await this.count(ctx, ...opts);
+		if (count === 0) return null;
+		return this.at(ctx, Math.floor(Math.random() * count), ...opts);
+	}
+	async paginate(ctx, ...opts) {
+		const result = await paginateHandler({ db: ctx.db }, {
+			...boundsToPositions(opts[0]?.bounds),
+			cursor: opts[0]?.cursor,
+			limit: opts[0]?.pageSize ?? 100,
+			namespace: namespaceForOpts(this.aggregateName, opts),
+			order: opts[0]?.order ?? "asc"
+		});
+		return {
+			cursor: result.cursor,
+			isDone: result.isDone,
+			page: result.page.map(btreeItemToAggregateItem)
+		};
+	}
+	async *iter(ctx, ...opts) {
+		const bounds = opts[0]?.bounds;
+		const namespace = namespaceFromOpts(opts);
+		const order = opts[0]?.order ?? "asc";
+		const pageSize = opts[0]?.pageSize ?? 100;
+		let cursor;
+		let isDone = false;
+		while (!isDone) {
+			const page = await this.paginate(ctx, {
+				bounds,
+				cursor,
+				namespace,
+				order,
+				pageSize
+			});
+			for (const item of page.page) yield item;
+			cursor = page.cursor;
+			isDone = page.isDone;
+		}
+	}
+	async _insert(ctx, namespace, key, id, summand) {
+		await insertHandler({ db: ctx.db }, {
+			key: keyToPosition(key, id),
+			namespace: namespaceForArg(this.aggregateName, { namespace }),
+			summand,
+			value: id
+		});
+	}
+	async _delete(ctx, namespace, key, id) {
+		await deleteHandler({ db: ctx.db }, {
+			key: keyToPosition(key, id),
+			namespace: namespaceForArg(this.aggregateName, { namespace })
+		});
+	}
+	async _replace(ctx, currentNamespace, currentKey, newNamespace, newKey, id, summand) {
+		await deleteHandler({ db: ctx.db }, {
+			key: keyToPosition(currentKey, id),
+			namespace: namespaceForArg(this.aggregateName, { namespace: currentNamespace })
+		});
+		await insertHandler({ db: ctx.db }, {
+			key: keyToPosition(newKey, id),
+			namespace: namespaceForArg(this.aggregateName, { namespace: newNamespace }),
+			summand,
+			value: id
+		});
+	}
+	async _insertIfDoesNotExist(ctx, namespace, key, id, summand) {
+		await this._replaceOrInsert(ctx, namespace, key, namespace, key, id, summand);
+	}
+	async _deleteIfExists(ctx, namespace, key, id) {
+		try {
+			await this._delete(ctx, namespace, key, id);
+		} catch (error) {
+			if (error instanceof ConvexError && error.data?.code === "DELETE_MISSING_KEY") return;
+			throw error;
+		}
+	}
+	async _replaceOrInsert(ctx, currentNamespace, currentKey, newNamespace, newKey, id, summand) {
+		try {
+			await this._delete(ctx, currentNamespace, currentKey, id);
+		} catch (error) {
+			if (!(error instanceof ConvexError && error.data?.code === "DELETE_MISSING_KEY")) throw error;
+		}
+		await this._insert(ctx, newNamespace, newKey, id, summand);
+	}
+	async clear(ctx, ...opts) {
+		await clearTree(ctx.db, {
+			maxNodeSize: opts[0]?.maxNodeSize,
+			namespace: namespaceForOpts(this.aggregateName, opts),
+			rootLazy: opts[0]?.rootLazy
+		});
+	}
+	async makeRootLazy(ctx, namespace) {
+		const tree = await getOrCreateTree(ctx.db, namespaceForArg(this.aggregateName, { namespace }));
+		await ctx.db.patch(tree.root, { aggregate: void 0 });
+	}
+	async paginateNamespaces(ctx, cursor, pageSize = 100) {
+		const result = await paginateNamespacesHandler({ db: ctx.db }, {
+			aggregateName: this.aggregateName,
+			cursor,
+			limit: pageSize
+		});
+		const page = [];
+		for (const namespace of result.page) {
+			if (!isInternalNamespace(namespace)) continue;
+			if (namespace[0] !== this.aggregateName) continue;
+			page.push(decodeNamespace(namespace));
+		}
+		return {
+			cursor: result.cursor,
+			isDone: result.isDone,
+			page
+		};
+	}
+	async *iterNamespaces(ctx, pageSize = 100) {
+		let cursor;
+		let isDone = false;
+		while (!isDone) {
+			const page = await this.paginateNamespaces(ctx, cursor, pageSize);
+			for (const namespace of page.page) yield namespace;
+			cursor = page.cursor;
+			isDone = page.isDone;
+		}
+	}
+	async clearAll(ctx, opts) {
+		for await (const namespace of this.iterNamespaces(ctx)) await this.clear(ctx, {
+			...opts,
+			namespace
+		});
+		await this.clear(ctx, {
+			...opts,
+			namespace: void 0
+		});
+	}
+	async makeAllRootsLazy(ctx) {
+		for await (const namespace of this.iterNamespaces(ctx)) await this.makeRootLazy(ctx, namespace);
+	}
+};
+var DirectAggregate = class extends Aggregate {
+	constructor(config) {
+		super(config.name);
+	}
+	async insert(ctx, args) {
+		await this._insert(ctx, namespaceFromArg(args), args.key, args.id, args.sumValue);
+	}
+	async delete(ctx, args) {
+		await this._delete(ctx, namespaceFromArg(args), args.key, args.id);
+	}
+	async replace(ctx, currentItem, newItem) {
+		await this._replace(ctx, namespaceFromArg(currentItem), currentItem.key, namespaceFromArg(newItem), newItem.key, currentItem.id, newItem.sumValue);
+	}
+	async insertIfDoesNotExist(ctx, args) {
+		await this._insertIfDoesNotExist(ctx, namespaceFromArg(args), args.key, args.id, args.sumValue);
+	}
+	async deleteIfExists(ctx, args) {
+		await this._deleteIfExists(ctx, namespaceFromArg(args), args.key, args.id);
+	}
+	async replaceOrInsert(ctx, currentItem, newItem) {
+		await this._replaceOrInsert(ctx, namespaceFromArg(currentItem), currentItem.key, namespaceFromArg(newItem), newItem.key, currentItem.id, newItem.sumValue);
+	}
+};
+var TableAggregate = class extends Aggregate {
+	constructor(options) {
+		super(options.name);
+		this.options = options;
+	}
+	options;
+	async insert(ctx, doc) {
+		await this._insert(ctx, this.options.namespace?.(doc), this.options.sortKey(doc), doc._id, this.options.sumValue?.(doc));
+	}
+	async delete(ctx, doc) {
+		await this._delete(ctx, this.options.namespace?.(doc), this.options.sortKey(doc), doc._id);
+	}
+	async replace(ctx, oldDoc, newDoc) {
+		await this._replace(ctx, this.options.namespace?.(oldDoc), this.options.sortKey(oldDoc), this.options.namespace?.(newDoc), this.options.sortKey(newDoc), newDoc._id, this.options.sumValue?.(newDoc));
+	}
+	async insertIfDoesNotExist(ctx, doc) {
+		await this._insertIfDoesNotExist(ctx, this.options.namespace?.(doc), this.options.sortKey(doc), doc._id, this.options.sumValue?.(doc));
+	}
+	async deleteIfExists(ctx, doc) {
+		await this._deleteIfExists(ctx, this.options.namespace?.(doc), this.options.sortKey(doc), doc._id);
+	}
+	async replaceOrInsert(ctx, oldDoc, newDoc) {
+		await this._replaceOrInsert(ctx, this.options.namespace?.(oldDoc), this.options.sortKey(oldDoc), this.options.namespace?.(newDoc), this.options.sortKey(newDoc), newDoc._id, this.options.sumValue?.(newDoc));
+	}
+	async indexOfDoc(ctx, doc, opts) {
+		return this.indexOf(ctx, this.options.sortKey(doc), {
+			namespace: this.options.namespace?.(doc),
+			...opts
+		});
+	}
+	trigger() {
+		return async (ctx, change) => {
+			if (change.operation === "insert") await this.insert(ctx, change.newDoc);
+			else if (change.operation === "update") await this.replace(ctx, change.oldDoc, change.newDoc);
+			else if (change.operation === "delete") await this.delete(ctx, change.oldDoc);
+		};
+	}
+	idempotentTrigger() {
+		return async (ctx, change) => {
+			if (change.operation === "insert") await this.insertIfDoesNotExist(ctx, change.newDoc);
+			else if (change.operation === "update") await this.replaceOrInsert(ctx, change.oldDoc, change.newDoc);
+			else if (change.operation === "delete") await this.deleteIfExists(ctx, change.oldDoc);
+		};
+	}
+};
+function btreeItemToAggregateItem({ k, s }) {
+	const { key, id } = positionToKey(k);
+	return {
+		id,
+		key,
+		sumValue: s
+	};
+}
+function namespaceFromArg(args) {
+	if ("namespace" in args) return args.namespace;
+}
+function namespaceFromOpts(opts) {
+	if (opts.length === 0) return;
+	const [{ namespace }] = opts;
+	return namespace;
+}
+
+//#endregion
+export { TableAggregate as n, aggregateStorageTables as r, DirectAggregate as t };