better-convex 0.7.3 → 0.8.0

package/dist/{runtime-B9xQFY8W.js → table-B7yzBihE.js}

@@ -1,42 +1,5 @@
-import { ConvexError, convexToJson, jsonToConvex, v } from "convex/values";
+import { 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/orm/builders/column-builder.ts
 /**
 * entityKind symbol for runtime type checking
@@ -167,69 +130,6 @@ var ConvexColumnBuilder = class extends ColumnBuilder {
 	static [entityKind] = "ConvexColumnBuilder";
 };
 
-//#endregion
-//#region src/orm/builders/custom.ts
-var ConvexCustomBuilder = class extends ConvexColumnBuilder {
-	static [entityKind] = "ConvexCustomBuilder";
-	constructor(name, validator) {
-		super(name, "any", "ConvexCustom");
-		this.config.validator = validator;
-	}
-	get convexValidator() {
-		const validator = this.config.validator;
-		if (this.config.notNull) return validator;
-		return v.optional(v.union(v.null(), validator));
-	}
-	build() {
-		return this.convexValidator;
-	}
-};
-function custom(a, b) {
-	if (b !== void 0) return new ConvexCustomBuilder(a, b);
-	return new ConvexCustomBuilder("", a);
-}
-/**
-* Convenience wrapper for Convex "JSON" values.
-*
-* Note: This is Convex JSON (runtime `v.any()`), not SQL JSON/JSONB.
-*/
-function json() {
-	return custom(v.any()).$type();
-}
-
-//#endregion
-//#region src/orm/builders/id.ts
-/**
-* ID column builder class
-* Compiles to v.id(tableName) or v.optional(v.id(tableName))
-*/
-var ConvexIdBuilder = class extends ConvexColumnBuilder {
-	static [entityKind] = "ConvexIdBuilder";
-	constructor(name, tableName) {
-		super(name, "string", "ConvexId");
-		this.tableName = tableName;
-		this.config.referenceTable = tableName;
-	}
-	/**
-	* Expose Convex validator for schema integration
-	*/
-	get convexValidator() {
-		if (this.config.notNull) return v.id(this.tableName);
-		return v.optional(v.union(v.null(), v.id(this.tableName)));
-	}
-	/**
-	* Compile to Convex validator
-	* .notNull() → v.id(tableName)
-	* nullable → v.optional(v.id(tableName))
-	*/
-	build() {
-		return this.convexValidator;
-	}
-};
-function id(tableName) {
-	return new ConvexIdBuilder("", tableName);
-}
-
 //#endregion
 //#region src/orm/builders/number.ts
 /**
@@ -631,6 +531,7 @@ const EnableRLS = Symbol.for("better-convex:EnableRLS");
 const TableDeleteConfig = Symbol.for("better-convex:TableDeleteConfig");
 const OrmSchemaOptions = Symbol.for("better-convex:OrmSchemaOptions");
 const OrmSchemaDefinition = Symbol.for("better-convex:OrmSchemaDefinition");
+const OrmSchemaPluginTables = Symbol.for("better-convex:OrmSchemaPluginTables");
 
 //#endregion
 //#region src/orm/table.ts
@@ -1291,990 +1192,4 @@ const convexTableWithRLS = (name, columns, extraConfig) => {
 const convexTable = Object.assign(convexTableInternal, { withRLS: convexTableWithRLS });
 
 //#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 { entityKind as A, text as C, custom as D, id as E, json as O, vectorIndex as S, integer as T, aggregateIndex as _, deletion as a, searchIndex as b, EnableRLS as c, OrmSchemaOptions as d, RlsPolicies as f, rlsPolicy as g, RlsPolicy as h, convexTable as i, ConvexColumnBuilder as k, OrmContext as l, TableName as m, TableAggregate as n, Brand as o, TableDeleteConfig as p, aggregateStorageTables as r, Columns as s, DirectAggregate as t, OrmSchemaDefinition as u, index as v, createSystemFields as w, uniqueIndex as x, rankIndex as y };
+export { integer as C, createSystemFields as S, entityKind as T, rankIndex as _, EnableRLS as a, vectorIndex as b, OrmSchemaOptions as c, TableDeleteConfig as d, TableName as f, index as g, aggregateIndex as h, Columns as i, OrmSchemaPluginTables as l, rlsPolicy as m, deletion as n, OrmContext as o, RlsPolicy as p, Brand as r, OrmSchemaDefinition as s, convexTable as t, RlsPolicies as u, searchIndex as v, ConvexColumnBuilder as w, text as x, uniqueIndex as y };