kitcn 0.0.1 → 0.12.1

package/dist/runtime-CtvJPkur.js

@@ -0,0 +1,2453 @@
+import { o as vRequired } from "./validators-B7oIJCAp.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/orm/builders/column-builder.ts
+/**
+* entityKind symbol for runtime type checking
+* Following Drizzle's pattern for type guards
+*/
+const entityKind = Symbol.for("kitcn:entityKind");
+/**
+* Base ColumnBuilder abstract class
+*
+* All column builders inherit from this class.
+* Implements chaining methods and stores runtime config.
+*/
+var ColumnBuilder = class {
+	static [entityKind] = "ColumnBuilder";
+	[entityKind] = "ColumnBuilder";
+	/**
+	* Runtime configuration - actual mutable state
+	*/
+	config;
+	constructor(name, dataType, columnType) {
+		this.config = {
+			name,
+			notNull: false,
+			default: void 0,
+			hasDefault: false,
+			primaryKey: false,
+			isUnique: false,
+			uniqueName: void 0,
+			uniqueNulls: void 0,
+			foreignKeyConfigs: [],
+			dataType,
+			columnType
+		};
+	}
+	/**
+	* Mark column as NOT NULL
+	* Returns type-branded instance with notNull: true
+	*/
+	notNull() {
+		this.config.notNull = true;
+		return this;
+	}
+	/**
+	* Override the TypeScript type for this column.
+	* Mirrors Drizzle's $type() (type-only, no runtime validation changes).
+	*/
+	$type() {
+		return this;
+	}
+	/**
+	* Set default value for column
+	* Makes field optional on insert
+	*/
+	default(value) {
+		this.config.default = value;
+		this.config.hasDefault = true;
+		return this;
+	}
+	/**
+	* Set default function for column (runtime evaluated on insert).
+	* Mirrors Drizzle's $defaultFn() / $default().
+	*/
+	$defaultFn(fn) {
+		this.config.defaultFn = fn;
+		return this;
+	}
+	/**
+	* Alias of $defaultFn for Drizzle parity.
+	*/
+	$default(fn) {
+		return this.$defaultFn(fn);
+	}
+	/**
+	* Set on-update function for column (runtime evaluated on update).
+	* Mirrors Drizzle's $onUpdateFn() / $onUpdate().
+	*/
+	$onUpdateFn(fn) {
+		this.config.onUpdateFn = fn;
+		return this;
+	}
+	/**
+	* Alias of $onUpdateFn for Drizzle parity.
+	*/
+	$onUpdate(fn) {
+		return this.$onUpdateFn(fn);
+	}
+	/**
+	* Mark column as primary key
+	* Implies NOT NULL
+	*/
+	primaryKey() {
+		this.config.primaryKey = true;
+		this.config.notNull = true;
+		return this;
+	}
+	/**
+	* Mark column as UNIQUE
+	* Mirrors Drizzle column unique API
+	*/
+	unique(name, config) {
+		this.config.isUnique = true;
+		this.config.uniqueName = name;
+		this.config.uniqueNulls = config?.nulls;
+		return this;
+	}
+	/**
+	* Define a foreign key reference
+	* Mirrors Drizzle column references() API
+	*/
+	references(ref, config = {}) {
+		this.config.foreignKeyConfigs.push({
+			ref,
+			config
+		});
+		return this;
+	}
+};
+
+//#endregion
+//#region src/orm/builders/convex-column-builder.ts
+/**
+* Convex-specific column builder base class
+*
+* All Convex column builders (ConvexTextBuilder, ConvexIntegerBuilder, etc.)
+* inherit from this class.
+*/
+var ConvexColumnBuilder = class extends ColumnBuilder {
+	static [entityKind] = "ConvexColumnBuilder";
+};
+
+//#endregion
+//#region src/orm/builders/custom.ts
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isValidator(value) {
+	return isRecord$1(value) && typeof value.kind === "string" && typeof value.isOptional === "string";
+}
+function isColumnBuilder$1(value) {
+	return isRecord$1(value) && value[entityKind] === "ColumnBuilder";
+}
+function toRequiredValidator(validator) {
+	return validator.isOptional === "optional" ? vRequired(validator) : validator;
+}
+function toRequiredBuilderValidator(validator) {
+	const requiredValidator = toRequiredValidator(validator);
+	if (requiredValidator.kind !== "union") return requiredValidator;
+	const nonNullMembers = requiredValidator.members.filter((member) => member.kind !== "null");
+	if (nonNullMembers.length !== 1) return requiredValidator;
+	const [member] = nonNullMembers;
+	if (member.kind === "object" || member.kind === "array") return member;
+	return requiredValidator;
+}
+function formatInvalidInput(path, value) {
+	return `${path} expected a column builder, Convex validator, or nested object shape. Got ${Array.isArray(value) ? "array" : value === null ? "null" : typeof value}.`;
+}
+function objectShapeToValidator(shape, path) {
+	const fields = {};
+	for (const [key, value] of Object.entries(shape)) fields[key] = nestedInputToValidator(value, `${path}.${key}`);
+	return v.object(fields);
+}
+function nestedInputToValidator(input, path) {
+	if (isColumnBuilder$1(input)) return toRequiredBuilderValidator(input.convexValidator);
+	if (isValidator(input)) return toRequiredValidator(input);
+	if (isRecord$1(input)) return objectShapeToValidator(input, path);
+	throw new Error(formatInvalidInput(path, input));
+}
+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);
+}
+/**
+* Creates an array column from a nested validator or builder.
+*
+* Values in nested arrays are always compiled as required validators.
+*/
+function arrayOf(element) {
+	return custom(v.array(nestedInputToValidator(element, "arrayOf(element)"))).$type();
+}
+/**
+* Creates a union column from validators/builders without dropping to `v.union(...)`.
+*/
+function unionOf(...members) {
+	const validators = members.map((member, index) => nestedInputToValidator(member, `unionOf(members[${index}])`));
+	return custom(v.union(...validators)).$type();
+}
+/**
+* Creates an object column from either:
+* - a nested shape of validators/builders, or
+* - a validator/builder describing homogeneous record values
+*
+* Fields in nested objects are always compiled as required validators.
+*/
+function objectOf(input) {
+	if (isColumnBuilder$1(input) || isValidator(input)) return custom(v.record(v.string(), nestedInputToValidator(input, "objectOf(value)"))).$type();
+	if (!isRecord$1(input)) throw new Error(formatInvalidInput("objectOf(shape)", input));
+	return custom(objectShapeToValidator(input, "objectOf(shape)")).$type();
+}
+/**
+* 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
+/**
+* Number column builder class
+* Compiles to v.number() or v.optional(v.number())
+*/
+var ConvexNumberBuilder = class extends ConvexColumnBuilder {
+	static [entityKind] = "ConvexNumberBuilder";
+	constructor(name) {
+		super(name, "number", "ConvexNumber");
+	}
+	/**
+	* Expose Convex validator for schema integration
+	*/
+	get convexValidator() {
+		if (this.config.notNull) return v.number();
+		return v.optional(v.union(v.null(), v.number()));
+	}
+	/**
+	* Compile to Convex validator
+	* .notNull() → v.number()
+	* nullable → v.optional(v.number())
+	*/
+	build() {
+		return this.convexValidator;
+	}
+};
+function integer(name) {
+	return new ConvexNumberBuilder(name ?? "");
+}
+
+//#endregion
+//#region src/orm/builders/system-fields.ts
+/**
+* System Fields - Convex-provided fields available on all documents
+*
+* id: Document ID (string, backed by internal Convex _id)
+* createdAt: Creation timestamp alias (backed by internal Convex _creationTime)
+*
+* These are automatically added to every Convex table.
+*/
+var ConvexSystemIdBuilder = class extends ColumnBuilder {
+	static [entityKind] = "ConvexSystemIdBuilder";
+	[entityKind] = "ConvexSystemIdBuilder";
+	constructor() {
+		super("_id", "string", "ConvexSystemId");
+		this.config.notNull = true;
+	}
+	build() {
+		return v.string();
+	}
+	/**
+	* Convex validator - runtime access
+	* System fields use v.string() for _id
+	*/
+	get convexValidator() {
+		return this.build();
+	}
+};
+var ConvexSystemCreationTimeBuilder = class extends ColumnBuilder {
+	static [entityKind] = "ConvexSystemCreationTimeBuilder";
+	[entityKind] = "ConvexSystemCreationTimeBuilder";
+	constructor() {
+		super("_creationTime", "number", "ConvexSystemCreationTime");
+		this.config.notNull = true;
+	}
+	build() {
+		return v.number();
+	}
+	/**
+	* Convex validator - runtime access
+	* System fields use v.number() for _creationTime
+	*/
+	get convexValidator() {
+		return this.build();
+	}
+};
+var ConvexSystemCreatedAtBuilder = class extends ColumnBuilder {
+	static [entityKind] = "ConvexSystemCreatedAtBuilder";
+	[entityKind] = "ConvexSystemCreatedAtBuilder";
+	constructor() {
+		super("_creationTime", "number", "ConvexSystemCreatedAt");
+		this.config.notNull = true;
+	}
+	build() {
+		return v.number();
+	}
+	get convexValidator() {
+		return this.build();
+	}
+};
+function createSystemFields(tableName) {
+	const id = new ConvexSystemIdBuilder();
+	const creationTime = new ConvexSystemCreationTimeBuilder();
+	const createdAt = new ConvexSystemCreatedAtBuilder();
+	id.config.tableName = tableName;
+	creationTime.config.tableName = tableName;
+	createdAt.config.tableName = tableName;
+	return {
+		id,
+		_creationTime: creationTime,
+		createdAt
+	};
+}
+
+//#endregion
+//#region src/orm/builders/text.ts
+/**
+* Text column builder class
+* Compiles to v.string() or v.optional(v.string())
+*/
+var ConvexTextBuilder = class extends ConvexColumnBuilder {
+	static [entityKind] = "ConvexTextBuilder";
+	constructor(name) {
+		super(name, "string", "ConvexText");
+	}
+	/**
+	* Expose Convex validator for schema integration
+	*/
+	get convexValidator() {
+		if (this.config.notNull) return v.string();
+		return v.optional(v.union(v.null(), v.string()));
+	}
+	/**
+	* Compile to Convex validator
+	* .notNull() → v.string()
+	* nullable → v.optional(v.string())
+	*/
+	build() {
+		return this.convexValidator;
+	}
+};
+function text(name) {
+	return new ConvexTextBuilder(name ?? "");
+}
+
+//#endregion
+//#region src/orm/indexes.ts
+var ConvexIndexBuilderOn = class {
+	static [entityKind] = "ConvexIndexBuilderOn";
+	[entityKind] = "ConvexIndexBuilderOn";
+	constructor(name, unique) {
+		this.name = name;
+		this.unique = unique;
+	}
+	on(...columns) {
+		return new ConvexIndexBuilder(this.name, columns, this.unique);
+	}
+};
+var ConvexIndexBuilder = class {
+	static [entityKind] = "ConvexIndexBuilder";
+	[entityKind] = "ConvexIndexBuilder";
+	config;
+	constructor(name, columns, unique) {
+		this.config = {
+			name,
+			columns,
+			unique,
+			where: void 0
+		};
+	}
+	/**
+	* Partial index conditions are not supported in Convex.
+	* This method is kept for Drizzle API parity.
+	*/
+	where(condition) {
+		this.config.where = condition;
+		return this;
+	}
+};
+var ConvexSearchIndexBuilderOn = class {
+	static [entityKind] = "ConvexSearchIndexBuilderOn";
+	[entityKind] = "ConvexSearchIndexBuilderOn";
+	constructor(name) {
+		this.name = name;
+	}
+	on(searchField) {
+		return new ConvexSearchIndexBuilder(this.name, searchField);
+	}
+};
+var ConvexSearchIndexBuilder = class {
+	static [entityKind] = "ConvexSearchIndexBuilder";
+	[entityKind] = "ConvexSearchIndexBuilder";
+	config;
+	constructor(name, searchField) {
+		this.config = {
+			name,
+			searchField,
+			filterFields: [],
+			staged: false
+		};
+	}
+	filter(...fields) {
+		this.config.filterFields = fields;
+		return this;
+	}
+	staged() {
+		this.config.staged = true;
+		return this;
+	}
+};
+var ConvexVectorIndexBuilderOn = class {
+	static [entityKind] = "ConvexVectorIndexBuilderOn";
+	[entityKind] = "ConvexVectorIndexBuilderOn";
+	constructor(name) {
+		this.name = name;
+	}
+	on(vectorField) {
+		return new ConvexVectorIndexBuilder(this.name, vectorField);
+	}
+};
+var ConvexAggregateIndexBuilderOn = class {
+	static [entityKind] = "ConvexAggregateIndexBuilderOn";
+	[entityKind] = "ConvexAggregateIndexBuilderOn";
+	constructor(name) {
+		this.name = name;
+	}
+	on(...columns) {
+		return new ConvexAggregateIndexBuilder(this.name, columns);
+	}
+	all() {
+		return new ConvexAggregateIndexBuilder(this.name, []);
+	}
+};
+var ConvexAggregateIndexBuilder = class {
+	static [entityKind] = "ConvexAggregateIndexBuilder";
+	[entityKind] = "ConvexAggregateIndexBuilder";
+	config;
+	constructor(name, columns) {
+		this.config = {
+			name,
+			columns,
+			countFields: [],
+			sumFields: [],
+			avgFields: [],
+			minFields: [],
+			maxFields: []
+		};
+	}
+	count(...fields) {
+		this.config.countFields = [...this.config.countFields, ...fields];
+		return this;
+	}
+	sum(...fields) {
+		this.config.sumFields = [...this.config.sumFields, ...fields];
+		return this;
+	}
+	avg(...fields) {
+		this.config.avgFields = [...this.config.avgFields, ...fields];
+		return this;
+	}
+	min(...fields) {
+		this.config.minFields = [...this.config.minFields, ...fields];
+		return this;
+	}
+	max(...fields) {
+		this.config.maxFields = [...this.config.maxFields, ...fields];
+		return this;
+	}
+};
+var ConvexRankIndexBuilderOn = class {
+	static [entityKind] = "ConvexRankIndexBuilderOn";
+	[entityKind] = "ConvexRankIndexBuilderOn";
+	constructor(name) {
+		this.name = name;
+	}
+	partitionBy(...columns) {
+		return new ConvexRankIndexBuilder(this.name, columns, []);
+	}
+	all() {
+		return new ConvexRankIndexBuilder(this.name, [], []);
+	}
+};
+var ConvexRankIndexBuilder = class {
+	static [entityKind] = "ConvexRankIndexBuilder";
+	[entityKind] = "ConvexRankIndexBuilder";
+	config;
+	constructor(name, partitionColumns, orderColumns) {
+		this.config = {
+			name,
+			partitionColumns,
+			orderColumns,
+			sumField: void 0
+		};
+	}
+	orderBy(...columns) {
+		this.config.orderColumns = columns.map((entry) => {
+			if (entry && typeof entry === "object" && "column" in entry && "direction" in entry) {
+				const builder = entry.column?.builder;
+				if (!builder) throw new Error("rankIndex orderBy() expected a column builder.");
+				return {
+					column: builder,
+					direction: entry.direction
+				};
+			}
+			return {
+				column: entry,
+				direction: "asc"
+			};
+		});
+		return this;
+	}
+	sum(field) {
+		this.config.sumField = field;
+		return this;
+	}
+};
+var ConvexVectorIndexBuilder = class {
+	static [entityKind] = "ConvexVectorIndexBuilder";
+	[entityKind] = "ConvexVectorIndexBuilder";
+	config;
+	constructor(name, vectorField) {
+		this.config = {
+			name,
+			vectorField,
+			dimensions: void 0,
+			filterFields: [],
+			staged: false
+		};
+	}
+	dimensions(dimensions) {
+		if (!Number.isInteger(dimensions)) throw new Error(`Vector index '${this.config.name}' dimensions must be an integer, got ${dimensions}`);
+		if (dimensions <= 0) throw new Error(`Vector index '${this.config.name}' dimensions must be positive, got ${dimensions}`);
+		if (dimensions > 1e4) console.warn(`Vector index '${this.config.name}' has unusually large dimensions (${dimensions}). Common values: 768, 1536, 3072`);
+		this.config.dimensions = dimensions;
+		return this;
+	}
+	filter(...fields) {
+		this.config.filterFields = fields;
+		return this;
+	}
+	staged() {
+		this.config.staged = true;
+		return this;
+	}
+};
+function index(name) {
+	return new ConvexIndexBuilderOn(name, false);
+}
+function uniqueIndex(name) {
+	return new ConvexIndexBuilderOn(name, true);
+}
+function searchIndex(name) {
+	return new ConvexSearchIndexBuilderOn(name);
+}
+function vectorIndex(name) {
+	return new ConvexVectorIndexBuilderOn(name);
+}
+function aggregateIndex(name) {
+	return new ConvexAggregateIndexBuilderOn(name);
+}
+function rankIndex(name) {
+	return new ConvexRankIndexBuilderOn(name);
+}
+
+//#endregion
+//#region src/orm/rls/policies.ts
+var RlsPolicy = class {
+	static [entityKind] = "RlsPolicy";
+	[entityKind] = "RlsPolicy";
+	as;
+	for;
+	to;
+	using;
+	withCheck;
+	/** @internal */
+	_linkedTable;
+	constructor(name, config) {
+		this.name = name;
+		if (config) {
+			this.as = config.as;
+			this.for = config.for;
+			this.to = config.to;
+			this.using = config.using;
+			this.withCheck = config.withCheck;
+		}
+	}
+	link(table) {
+		this._linkedTable = table;
+		return this;
+	}
+};
+function rlsPolicy(name, config) {
+	return new RlsPolicy(name, config);
+}
+function isRlsPolicy(value) {
+	return !!value && typeof value === "object" && value[entityKind] === "RlsPolicy";
+}
+
+//#endregion
+//#region src/orm/symbols.ts
+const TableName = Symbol.for("kitcn:TableName");
+const Columns = Symbol.for("kitcn:Columns");
+const Brand = Symbol.for("kitcn:Brand");
+const Relations = Symbol.for("kitcn:Relations");
+const OrmContext = Symbol.for("kitcn:OrmContext");
+const RlsPolicies = Symbol.for("kitcn:RlsPolicies");
+const EnableRLS = Symbol.for("kitcn:EnableRLS");
+const TableDeleteConfig = Symbol.for("kitcn:TableDeleteConfig");
+const TablePolymorphic = Symbol.for("kitcn:TablePolymorphic");
+const OrmSchemaOptions = Symbol.for("kitcn:OrmSchemaOptions");
+const OrmSchemaDefinition = Symbol.for("kitcn:OrmSchemaDefinition");
+const OrmSchemaExtensionTables = Symbol.for("kitcn:OrmSchemaExtensionTables");
+const OrmSchemaExtensions = Symbol.for("kitcn:OrmSchemaExtensions");
+const OrmSchemaExtensionRelations = Symbol.for("kitcn:OrmSchemaExtensionRelations");
+const OrmSchemaExtensionTriggers = Symbol.for("kitcn:OrmSchemaExtensionTriggers");
+const OrmSchemaRelations = Symbol.for("kitcn:OrmSchemaRelations");
+const OrmSchemaTriggers = Symbol.for("kitcn:OrmSchemaTriggers");
+
+//#endregion
+//#region src/orm/table.ts
+/**
+* Reserved Convex system table names that cannot be used
+*/
+const RESERVED_TABLES = new Set(["_storage", "_scheduled_functions"]);
+const RESERVED_COLUMN_NAMES = new Set([
+	"id",
+	"_id",
+	"_creationTime"
+]);
+const DEFAULT_POLYMORPHIC_ALIAS = "details";
+const CONVEX_TABLE_FIELD_LIMIT = 1024;
+/**
+* Valid table name pattern: starts with letter/underscore, contains only alphanumeric and underscore
+*/
+const TABLE_NAME_REGEX = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+/**
+* Validate table name against Convex constraints
+*/
+function validateTableName(name) {
+	if (RESERVED_TABLES.has(name)) throw new Error(`Table name '${name}' is reserved. System tables cannot be redefined.`);
+	if (!TABLE_NAME_REGEX.test(name)) throw new Error(`Invalid table name '${name}'. Must start with letter, contain only alphanumeric and underscore.`);
+}
+/**
+* Create a Convex object validator from column builders
+*
+* Extracts .convexValidator from each column and creates v.object({...})
+* This is the core factory that bridges ORM columns to Convex validators.
+*
+* @param columns - Record of column name to column builder
+* @returns Convex object validator
+*/
+function createValidatorFromColumns(columns) {
+	const validatorFields = Object.fromEntries(Object.entries(columns).map(([key, builder]) => [key, builder.convexValidator]));
+	return v.object(validatorFields);
+}
+function discriminator(config) {
+	if (!config || typeof config !== "object") throw new Error("discriminator(...) requires a config object.");
+	if (!config.variants || typeof config.variants !== "object" || Object.keys(config.variants).length === 0) throw new Error("discriminator(...).variants must contain at least one case.");
+	if (config.as !== void 0 && (typeof config.as !== "string" || config.as.length === 0)) throw new Error("discriminator(...).as must be a non-empty string when set.");
+	const builder = text().notNull();
+	builder.__polymorphic = {
+		as: config.as ?? DEFAULT_POLYMORPHIC_ALIAS,
+		variants: config.variants
+	};
+	builder.config.discriminator = {
+		as: config.as,
+		variants: config.variants
+	};
+	return builder;
+}
+var ConvexDeletionBuilder = class {
+	static [entityKind] = "ConvexDeletionBuilder";
+	[entityKind] = "ConvexDeletionBuilder";
+	constructor(config) {
+		this.config = config;
+	}
+};
+function deletion(mode, options) {
+	if (options?.delayMs !== void 0) {
+		if (mode !== "scheduled") throw new Error("deletion() delayMs is only supported for 'scheduled'.");
+		if (!Number.isInteger(options.delayMs) || options.delayMs < 0) throw new Error("deletion() delayMs must be a non-negative integer when mode is 'scheduled'.");
+	}
+	return new ConvexDeletionBuilder({
+		mode,
+		delayMs: options?.delayMs
+	});
+}
+function isConvexIndexBuilder(value) {
+	return typeof value === "object" && value !== null && value[entityKind] === "ConvexIndexBuilder";
+}
+function isConvexIndexBuilderOn(value) {
+	return typeof value === "object" && value !== null && value[entityKind] === "ConvexIndexBuilderOn";
+}
+function isConvexAggregateIndexBuilder(value) {
+	return typeof value === "object" && value !== null && value[entityKind] === "ConvexAggregateIndexBuilder";
+}
+function isConvexAggregateIndexBuilderOn(value) {
+	return typeof value === "object" && value !== null && value[entityKind] === "ConvexAggregateIndexBuilderOn";
+}
+function isConvexRankIndexBuilderOn(value) {
+	return typeof value === "object" && value !== null && value[entityKind] === "ConvexRankIndexBuilderOn";
+}
+function isConvexRankIndexBuilder(value) {
+	return typeof value === "object" && value !== null && value[entityKind] === "ConvexRankIndexBuilder";
+}
+function isConvexUniqueConstraintBuilderOn(value) {
+	return typeof value === "object" && value !== null && value[entityKind] === "ConvexUniqueConstraintBuilderOn";
+}
+function isConvexForeignKeyBuilder(value) {
+	return typeof value === "object" && value !== null && value[entityKind] === "ConvexForeignKeyBuilder";
+}
+function isConvexCheckBuilder(value) {
+	return typeof value === "object" && value !== null && value[entityKind] === "ConvexCheckBuilder";
+}
+function isConvexSearchIndexBuilderOn(value) {
+	return typeof value === "object" && value !== null && value[entityKind] === "ConvexSearchIndexBuilderOn";
+}
+function isConvexUniqueConstraintBuilder(value) {
+	return typeof value === "object" && value !== null && value[entityKind] === "ConvexUniqueConstraintBuilder";
+}
+function isConvexSearchIndexBuilder(value) {
+	return typeof value === "object" && value !== null && value[entityKind] === "ConvexSearchIndexBuilder";
+}
+function isConvexVectorIndexBuilderOn(value) {
+	return typeof value === "object" && value !== null && value[entityKind] === "ConvexVectorIndexBuilderOn";
+}
+function isConvexVectorIndexBuilder(value) {
+	return typeof value === "object" && value !== null && value[entityKind] === "ConvexVectorIndexBuilder";
+}
+function isConvexDeletionBuilder(value) {
+	return typeof value === "object" && value !== null && value[entityKind] === "ConvexDeletionBuilder";
+}
+function isConvexLifecycleBuilder(value) {
+	return typeof value === "object" && value !== null && value[entityKind] === "ConvexLifecycleBuilder";
+}
+function getColumnName(column) {
+	const config = column.config;
+	if (!config?.name) throw new Error("Invalid index column: expected a convexTable column builder.");
+	return config.name;
+}
+function getColumnType(column) {
+	return column.config?.columnType;
+}
+function getColumnDimensions(column) {
+	return column.config?.dimensions;
+}
+function getColumnTableName(column) {
+	const config = column.config;
+	return config?.tableName ?? config?.referenceTable;
+}
+function getColumnTable(column) {
+	return column.config?.table;
+}
+function getUniqueIndexName(tableName, fields, explicitName) {
+	if (explicitName) return explicitName;
+	return `${tableName}_${fields.join("_")}_unique`;
+}
+function assertColumnInTable(column, expectedTable, context) {
+	const tableName = getColumnTableName(column);
+	if (tableName && tableName !== expectedTable) throw new Error(`${context} references column from '${tableName}', but belongs to '${expectedTable}'.`);
+	return getColumnName(column);
+}
+function assertNoReservedCreatedAtIndexFields(fields, context) {
+	if (fields.includes("createdAt")) throw new Error(`${context} cannot use 'createdAt'. 'createdAt' is reserved and maps to internal '_creationTime'.`);
+}
+function assertSearchFieldType(column, indexName) {
+	const columnType = getColumnType(column) ?? "unknown";
+	if (columnType !== "ConvexText") throw new Error(`Search index '${indexName}' only supports text() columns. Field '${getColumnName(column)}' is type '${columnType}'.`);
+}
+function assertVectorFieldType(column, indexName) {
+	const columnType = getColumnType(column) ?? "unknown";
+	if (columnType !== "ConvexVector") throw new Error(`Vector index '${indexName}' requires a vector() column. Field '${getColumnName(column)}' is type '${columnType}'.`);
+}
+function assertAggregateSumFieldType(column, indexName) {
+	const columnType = getColumnType(column) ?? "unknown";
+	if (!["ConvexNumber", "ConvexTimestamp"].includes(columnType)) throw new Error(`aggregateIndex '${indexName}' sum() supports integer()/timestamp() columns only. Field '${getColumnName(column)}' is type '${columnType}'.`);
+}
+function assertAggregateAvgFieldType(column, indexName) {
+	const columnType = getColumnType(column) ?? "unknown";
+	if (!["ConvexNumber", "ConvexTimestamp"].includes(columnType)) throw new Error(`aggregateIndex '${indexName}' avg() supports integer()/timestamp() columns only. Field '${getColumnName(column)}' is type '${columnType}'.`);
+}
+function assertAggregateComparableFieldType(column, indexName, method) {
+	const columnType = getColumnType(column) ?? "unknown";
+	if (![
+		"ConvexNumber",
+		"ConvexTimestamp",
+		"ConvexDate",
+		"ConvexText",
+		"ConvexBoolean",
+		"ConvexId"
+	].includes(columnType)) throw new Error(`aggregateIndex '${indexName}' ${method}() does not support column type '${columnType}' on '${getColumnName(column)}'.`);
+}
+function assertRankOrderFieldType(column, indexName) {
+	const columnType = getColumnType(column) ?? "unknown";
+	if (![
+		"ConvexNumber",
+		"ConvexTimestamp",
+		"ConvexDate"
+	].includes(columnType)) throw new Error(`rankIndex '${indexName}' orderBy() supports integer()/timestamp()/date() columns only. Field '${getColumnName(column)}' is type '${columnType}'.`);
+}
+const dedupeFieldNames = (fields) => [...new Set(fields)];
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isColumnBuilder = (value) => isRecord(value) && typeof value.build === "function";
+const getDiscriminatorConfig = (value) => {
+	if (!isColumnBuilder(value)) return;
+	const discriminator = value.config?.discriminator;
+	if (!discriminator) return;
+	return discriminator;
+};
+const getPolymorphicFieldSignature = (column) => {
+	const validator = column.convexValidator ?? column.build();
+	return JSON.stringify({
+		columnType: column.config?.columnType,
+		validator: validator?.json
+	});
+};
+function resolveTableColumns(tableName, columns) {
+	const resolvedColumns = {};
+	const pendingPolymorphic = [];
+	for (const [columnName, rawBuilder] of Object.entries(columns)) {
+		if (!isColumnBuilder(rawBuilder)) throw new Error(`Column '${columnName}' on '${tableName}' must be a column builder.`);
+		resolvedColumns[columnName] = rawBuilder;
+		const discriminatorConfig = getDiscriminatorConfig(rawBuilder);
+		if (!discriminatorConfig) continue;
+		if (!isRecord(discriminatorConfig.variants) || Object.keys(discriminatorConfig.variants).length === 0) throw new Error(`discriminator('${tableName}.${columnName}') requires at least one variant.`);
+		const alias = discriminatorConfig.as === void 0 ? DEFAULT_POLYMORPHIC_ALIAS : discriminatorConfig.as;
+		if (typeof alias !== "string" || alias.length === 0) throw new Error(`discriminator('${tableName}.${columnName}').as must be a non-empty string.`);
+		pendingPolymorphic.push({
+			discriminator: columnName,
+			alias,
+			variants: discriminatorConfig.variants
+		});
+	}
+	if (pendingPolymorphic.length > 1) throw new Error(`Only one discriminator(...) column is currently supported on '${tableName}'.`);
+	const polymorphicConfigs = [];
+	for (const pending of pendingPolymorphic) {
+		if (pending.alias in resolvedColumns) throw new Error(`discriminator('${tableName}.${pending.discriminator}') alias '${pending.alias}' collides with an existing column.`);
+		const generatedFieldMap = /* @__PURE__ */ new Map();
+		const variantRuntime = {};
+		for (const [variantKey, rawVariantColumns] of Object.entries(pending.variants)) {
+			if (!isRecord(rawVariantColumns)) throw new Error(`discriminator('${tableName}.${pending.discriminator}') variant '${variantKey}' must be an object.`);
+			const fieldNames = [];
+			const requiredFieldNames = [];
+			for (const [fieldName, rawFieldBuilder] of Object.entries(rawVariantColumns)) {
+				if (!isColumnBuilder(rawFieldBuilder)) throw new Error(`discriminator('${tableName}.${pending.discriminator}').variants.${variantKey}.${fieldName} must be a column builder.`);
+				if (fieldName in resolvedColumns) throw new Error(`discriminator('${tableName}.${pending.discriminator}').variants.${variantKey}.${fieldName} collides with an existing table column.`);
+				const fieldBuilder = rawFieldBuilder;
+				const fieldConfig = fieldBuilder.config;
+				const isRequiredForVariant = fieldConfig?.notNull === true && fieldConfig.hasDefault !== true && typeof fieldConfig.defaultFn !== "function";
+				const signature = getPolymorphicFieldSignature(fieldBuilder);
+				const existing = generatedFieldMap.get(fieldName);
+				if (existing && existing.signature !== signature) throw new Error(`discriminator('${tableName}.${pending.discriminator}') field '${fieldName}' has conflicting builder signatures across variants.`);
+				if (!existing) {
+					if (fieldConfig) fieldConfig.notNull = false;
+					generatedFieldMap.set(fieldName, {
+						builder: fieldBuilder,
+						signature
+					});
+				}
+				fieldNames.push(fieldName);
+				if (isRequiredForVariant) requiredFieldNames.push(fieldName);
+			}
+			variantRuntime[variantKey] = {
+				fieldNames,
+				requiredFieldNames
+			};
+		}
+		for (const [fieldName, { builder }] of generatedFieldMap.entries()) resolvedColumns[fieldName] = builder;
+		polymorphicConfigs.push({
+			discriminator: pending.discriminator,
+			alias: pending.alias,
+			generatedFieldNames: Object.freeze([...generatedFieldMap.keys()]),
+			variants: Object.freeze(variantRuntime)
+		});
+	}
+	if (Object.keys(resolvedColumns).length > CONVEX_TABLE_FIELD_LIMIT) throw new Error(`Table '${tableName}' exceeds Convex field count limit (${CONVEX_TABLE_FIELD_LIMIT}) after discriminator expansion.`);
+	return {
+		columns: resolvedColumns,
+		polymorphicConfigs
+	};
+}
+function applyExtraConfig(table, config) {
+	if (!config) return;
+	const entries = Array.isArray(config) ? config : Object.values(config);
+	for (const entry of entries) {
+		if (isConvexIndexBuilderOn(entry)) throw new Error(`Invalid index definition on '${table.tableName}'. Did you forget to call .on(...)?`);
+		if (isConvexUniqueConstraintBuilderOn(entry)) throw new Error(`Invalid unique constraint definition on '${table.tableName}'. Did you forget to call .on(...)?`);
+		if (isConvexAggregateIndexBuilderOn(entry)) throw new Error(`Invalid aggregate index definition on '${table.tableName}'. Did you forget to call .on(...) or .all()?`);
+		if (isConvexRankIndexBuilderOn(entry)) throw new Error(`Invalid rank index definition on '${table.tableName}'. Did you forget to call .partitionBy(...) or .all()?`);
+		if (isConvexSearchIndexBuilderOn(entry)) throw new Error(`Invalid search index definition on '${table.tableName}'. Did you forget to call .on(...)?`);
+		if (isConvexVectorIndexBuilderOn(entry)) throw new Error(`Invalid vector index definition on '${table.tableName}'. Did you forget to call .on(...)?`);
+		if (isRlsPolicy(entry)) {
+			const target = entry._linkedTable ?? table;
+			if (typeof target.addRlsPolicy === "function") target.addRlsPolicy(entry);
+			else {
+				const policies = target[RlsPolicies] ?? [];
+				policies.push(entry);
+				target[RlsPolicies] = policies;
+				target[EnableRLS] = true;
+			}
+			continue;
+		}
+		if (isConvexDeletionBuilder(entry)) {
+			if (table[TableDeleteConfig]) throw new Error(`Only one deletion(...) config can be defined for '${table.tableName}'.`);
+			table[TableDeleteConfig] = {
+				mode: entry.config.mode,
+				delayMs: entry.config.delayMs
+			};
+			continue;
+		}
+		if (isConvexLifecycleBuilder(entry)) throw new Error(`Lifecycle hooks are no longer supported inside convexTable('${table.tableName}', ..., extraConfig). Export schema triggers with defineTriggers(relations, { ... }) from schema.ts.`);
+		if (isConvexIndexBuilder(entry)) {
+			const { name, columns, unique, where } = entry.config;
+			if (where) throw new Error(`Convex does not support partial indexes. Remove .where(...) from index '${name}'.`);
+			if (unique) {}
+			const fields = columns.map((column) => assertColumnInTable(column, table.tableName, `Index '${name}'`));
+			assertNoReservedCreatedAtIndexFields(fields, `Index '${name}'`);
+			table.addIndex(name, fields);
+			if (unique) table.addUniqueIndex(name, fields, false);
+			continue;
+		}
+		if (isConvexAggregateIndexBuilder(entry)) {
+			const { name, columns, countFields, sumFields, avgFields, minFields, maxFields } = entry.config;
+			const fields = columns.map((column) => assertColumnInTable(column, table.tableName, `Aggregate index '${name}'`));
+			assertNoReservedCreatedAtIndexFields(fields, `Aggregate index '${name}'`);
+			const resolvedCountFields = dedupeFieldNames(countFields.map((column) => assertColumnInTable(column, table.tableName, `Aggregate index '${name}' count`)));
+			assertNoReservedCreatedAtIndexFields(resolvedCountFields, `Aggregate index '${name}' count`);
+			const resolvedSumFields = dedupeFieldNames(sumFields.map((column) => {
+				const field = assertColumnInTable(column, table.tableName, `Aggregate index '${name}' sum`);
+				assertAggregateSumFieldType(column, name);
+				return field;
+			}));
+			assertNoReservedCreatedAtIndexFields(resolvedSumFields, `Aggregate index '${name}' sum`);
+			const resolvedAvgFields = dedupeFieldNames(avgFields.map((column) => {
+				const field = assertColumnInTable(column, table.tableName, `Aggregate index '${name}' avg`);
+				assertAggregateAvgFieldType(column, name);
+				return field;
+			}));
+			assertNoReservedCreatedAtIndexFields(resolvedAvgFields, `Aggregate index '${name}' avg`);
+			const resolvedMinFields = dedupeFieldNames(minFields.map((column) => {
+				const field = assertColumnInTable(column, table.tableName, `Aggregate index '${name}' min`);
+				assertAggregateComparableFieldType(column, name, "min");
+				return field;
+			}));
+			assertNoReservedCreatedAtIndexFields(resolvedMinFields, `Aggregate index '${name}' min`);
+			const resolvedMaxFields = dedupeFieldNames(maxFields.map((column) => {
+				const field = assertColumnInTable(column, table.tableName, `Aggregate index '${name}' max`);
+				assertAggregateComparableFieldType(column, name, "max");
+				return field;
+			}));
+			assertNoReservedCreatedAtIndexFields(resolvedMaxFields, `Aggregate index '${name}' max`);
+			table.addAggregateIndex(name, {
+				fields,
+				countFields: resolvedCountFields,
+				sumFields: resolvedSumFields,
+				avgFields: resolvedAvgFields,
+				minFields: resolvedMinFields,
+				maxFields: resolvedMaxFields
+			});
+			continue;
+		}
+		if (isConvexRankIndexBuilder(entry)) {
+			const { name, partitionColumns, orderColumns, sumField } = entry.config;
+			if (!orderColumns.length) throw new Error(`rankIndex '${name}' on '${table.tableName}' must declare at least one orderBy(...) column.`);
+			const resolvedPartitionFields = dedupeFieldNames(partitionColumns.map((column) => assertColumnInTable(column, table.tableName, `rankIndex '${name}'`)));
+			assertNoReservedCreatedAtIndexFields(resolvedPartitionFields, `rankIndex '${name}' partitionBy`);
+			const resolvedOrderFields = orderColumns.map((entry) => {
+				const field = assertColumnInTable(entry.column, table.tableName, `rankIndex '${name}' orderBy`);
+				assertNoReservedCreatedAtIndexFields([field], `rankIndex '${name}'`);
+				assertRankOrderFieldType(entry.column, name);
+				return {
+					field,
+					direction: entry.direction
+				};
+			});
+			const resolvedSumField = sumField ? (() => {
+				const field = assertColumnInTable(sumField, table.tableName, `rankIndex '${name}' sum`);
+				assertNoReservedCreatedAtIndexFields([field], `rankIndex '${name}'`);
+				assertAggregateSumFieldType(sumField, name);
+				return field;
+			})() : void 0;
+			table.addRankIndex(name, {
+				partitionFields: resolvedPartitionFields,
+				orderFields: resolvedOrderFields,
+				sumField: resolvedSumField
+			});
+			continue;
+		}
+		if (isConvexUniqueConstraintBuilder(entry)) {
+			const { name, columns, nullsNotDistinct } = entry.config;
+			const fields = columns.map((column) => assertColumnInTable(column, table.tableName, "Unique constraint"));
+			assertNoReservedCreatedAtIndexFields(fields, "Unique constraint");
+			const indexName = getUniqueIndexName(table.tableName, fields, name);
+			table.addIndex(indexName, fields);
+			table.addUniqueIndex(indexName, fields, nullsNotDistinct);
+			continue;
+		}
+		if (isConvexForeignKeyBuilder(entry)) {
+			const { name, columns, foreignColumns, onDelete, onUpdate } = entry.config;
+			if (columns.length === 0 || foreignColumns.length === 0) throw new Error(`Foreign key on '${table.tableName}' requires at least one column.`);
+			if (columns.length !== foreignColumns.length) throw new Error(`Foreign key on '${table.tableName}' must specify matching columns and foreignColumns.`);
+			const localFields = columns.map((column) => assertColumnInTable(column, table.tableName, "Foreign key"));
+			const foreignTableName = getColumnTableName(foreignColumns[0]);
+			if (!foreignTableName) throw new Error(`Foreign key on '${table.tableName}' references a column without a table.`);
+			const foreignTable = getColumnTable(foreignColumns[0]);
+			const foreignFields = foreignColumns.map((column) => {
+				const tableName = getColumnTableName(column);
+				if (tableName && tableName !== foreignTableName) throw new Error(`Foreign key on '${table.tableName}' mixes foreign columns from '${foreignTableName}' and '${tableName}'.`);
+				return getColumnName(column);
+			});
+			table.addForeignKey({
+				name,
+				columns: localFields,
+				foreignTableName,
+				foreignTable,
+				foreignColumns: foreignFields,
+				onDelete,
+				onUpdate
+			});
+			continue;
+		}
+		if (isConvexCheckBuilder(entry)) {
+			const { name, expression } = entry.config;
+			table.addCheck(name, expression);
+			continue;
+		}
+		if (isConvexSearchIndexBuilder(entry)) {
+			const { name, searchField, filterFields, staged } = entry.config;
+			const searchFieldName = assertColumnInTable(searchField, table.tableName, `Search index '${name}'`);
+			assertNoReservedCreatedAtIndexFields([searchFieldName], `Search index '${name}'`);
+			assertSearchFieldType(searchField, name);
+			const filterFieldNames = filterFields.map((field) => assertColumnInTable(field, table.tableName, `Search index '${name}'`));
+			assertNoReservedCreatedAtIndexFields(filterFieldNames, `Search index '${name}'`);
+			table.addSearchIndex(name, {
+				searchField: searchFieldName,
+				filterFields: filterFieldNames,
+				staged
+			});
+			continue;
+		}
+		if (isConvexVectorIndexBuilder(entry)) {
+			const { name, vectorField, dimensions, filterFields, staged } = entry.config;
+			if (dimensions === void 0) throw new Error(`Vector index '${name}' is missing dimensions. Call .dimensions(n) before using.`);
+			const vectorFieldName = assertColumnInTable(vectorField, table.tableName, `Vector index '${name}'`);
+			assertNoReservedCreatedAtIndexFields([vectorFieldName], `Vector index '${name}'`);
+			assertVectorFieldType(vectorField, name);
+			const columnDimensions = getColumnDimensions(vectorField);
+			if (columnDimensions !== void 0 && columnDimensions !== dimensions) throw new Error(`Vector index '${name}' dimensions (${dimensions}) do not match vector column '${vectorFieldName}' dimensions (${columnDimensions}).`);
+			const filterFieldNames = filterFields.map((field) => assertColumnInTable(field, table.tableName, `Vector index '${name}'`));
+			assertNoReservedCreatedAtIndexFields(filterFieldNames, `Vector index '${name}'`);
+			table.addVectorIndex(name, {
+				vectorField: vectorFieldName,
+				dimensions,
+				filterFields: filterFieldNames,
+				staged
+			});
+			continue;
+		}
+		throw new Error(`Unsupported extra config value in convexTable('${table.tableName}').`);
+	}
+}
+/**
+* ConvexTable implementation class
+* Provides all properties required by Convex's TableDefinition
+*
+* Following convex-ents pattern:
+* - Private fields for indexes (matches TableDefinition structure)
+* - Duck typing (defineSchema only checks object shape)
+* - Direct validator storage (no re-wrapping)
+*/
+var ConvexTableImpl = class {
+	/**
+	* Required by TableDefinition
+	* Public validator property containing v.object({...}) with all column validators
+	*/
+	validator;
+	/**
+	* TableDefinition private fields
+	* These satisfy structural typing requirements for defineSchema()
+	*/
+	indexes = [];
+	uniqueIndexes = [];
+	aggregateIndexes = [];
+	rankIndexes = [];
+	foreignKeys = [];
+	deferredForeignKeys = [];
+	deferredForeignKeysResolved = false;
+	stagedDbIndexes = [];
+	searchIndexes = [];
+	stagedSearchIndexes = [];
+	vectorIndexes = [];
+	stagedVectorIndexes = [];
+	checks = [];
+	/**
+	* Symbol-based metadata storage
+	*/
+	[TableName];
+	[Columns];
+	[Brand] = "ConvexTable";
+	[EnableRLS] = false;
+	[RlsPolicies] = [];
+	[TableDeleteConfig];
+	[TablePolymorphic];
+	/**
+	* Public tableName for convenience
+	*/
+	tableName;
+	constructor(name, columns, polymorphicConfigs) {
+		validateTableName(name);
+		for (const columnName of Object.keys(columns)) if (RESERVED_COLUMN_NAMES.has(columnName)) throw new Error(`Column name '${columnName}' is reserved. System fields are managed by Convex ORM.`);
+		this[TableName] = name;
+		const namedColumns = Object.fromEntries(Object.entries(columns).map(([columnName, builder]) => {
+			builder.config.name = columnName;
+			builder.config.tableName = name;
+			builder.config.table = this;
+			return [columnName, builder];
+		}));
+		this[Columns] = namedColumns;
+		this.tableName = name;
+		if (polymorphicConfigs && polymorphicConfigs.length > 0) this[TablePolymorphic] = polymorphicConfigs;
+		this.validator = createValidatorFromColumns(namedColumns);
+		for (const [columnName, builder] of Object.entries(namedColumns)) {
+			const config = builder.config;
+			if (config?.isUnique) {
+				const indexName = getUniqueIndexName(name, [columnName], config.uniqueName);
+				const nullsNotDistinct = config.uniqueNulls === "not distinct";
+				this.addIndex(indexName, [columnName]);
+				this.addUniqueIndex(indexName, [columnName], nullsNotDistinct);
+			}
+			if (config?.referenceTable && (!config.foreignKeyConfigs || config.foreignKeyConfigs.length === 0)) this.addForeignKey({
+				name: void 0,
+				columns: [columnName],
+				foreignTableName: config.referenceTable,
+				foreignColumns: ["_id"]
+			});
+			if (config?.foreignKeyConfigs?.length) for (const foreignConfig of config.foreignKeyConfigs) this.deferredForeignKeys.push({
+				localColumnName: columnName,
+				ref: foreignConfig.ref,
+				config: foreignConfig.config
+			});
+		}
+	}
+	getPolymorphicConfigs() {
+		return this[TablePolymorphic];
+	}
+	/**
+	* Internal: add index to table from builder extraConfig
+	*
+	*/
+	addIndex(name, fields) {
+		this.indexes.push({
+			indexDescriptor: name,
+			fields
+		});
+	}
+	/**
+	* Internal: add unique index metadata for runtime enforcement
+	*/
+	addUniqueIndex(name, fields, nullsNotDistinct) {
+		this.uniqueIndexes.push({
+			name,
+			fields,
+			nullsNotDistinct
+		});
+	}
+	addAggregateIndex(name, config) {
+		if (this.aggregateIndexes.some((index) => index.name === name) || this.rankIndexes.some((index) => index.name === name)) throw new Error(`Duplicate aggregate index '${name}' on '${this.tableName}'.`);
+		this.aggregateIndexes.push({
+			name,
+			fields: config.fields,
+			countFields: config.countFields,
+			sumFields: config.sumFields,
+			avgFields: config.avgFields,
+			minFields: config.minFields,
+			maxFields: config.maxFields
+		});
+	}
+	addRankIndex(name, config) {
+		if (this.rankIndexes.some((index) => index.name === name) || this.aggregateIndexes.some((index) => index.name === name)) throw new Error(`Duplicate aggregate index '${name}' on '${this.tableName}'.`);
+		this.rankIndexes.push({
+			name,
+			partitionFields: config.partitionFields,
+			orderFields: config.orderFields,
+			sumField: config.sumField
+		});
+	}
+	getAggregateIndexes() {
+		return [...this.aggregateIndexes];
+	}
+	getRankIndexes() {
+		return [...this.rankIndexes];
+	}
+	/**
+	* Internal: expose unique index metadata for mutation enforcement
+	*/
+	getUniqueIndexes() {
+		return this.uniqueIndexes;
+	}
+	/**
+	* Internal: expose index metadata for runtime enforcement
+	*/
+	getIndexes() {
+		return this.indexes.map((entry) => ({
+			name: entry.indexDescriptor,
+			fields: entry.fields
+		}));
+	}
+	/**
+	* Internal: expose search index metadata for runtime query execution
+	*/
+	getSearchIndexes() {
+		return this.searchIndexes.map((entry) => ({
+			name: entry.indexDescriptor,
+			searchField: entry.searchField,
+			filterFields: entry.filterFields
+		}));
+	}
+	/**
+	* Internal: expose vector index metadata for runtime query execution
+	*/
+	getVectorIndexes() {
+		return this.vectorIndexes.map((entry) => ({
+			name: entry.indexDescriptor,
+			vectorField: entry.vectorField,
+			dimensions: entry.dimensions,
+			filterFields: entry.filterFields
+		}));
+	}
+	/**
+	* Internal: attach an RLS policy to this table
+	*/
+	addRlsPolicy(policy) {
+		this[RlsPolicies].push(policy);
+		this[EnableRLS] = true;
+	}
+	/**
+	* Internal: return attached RLS policies
+	*/
+	getRlsPolicies() {
+		return this[RlsPolicies];
+	}
+	/**
+	* Internal: check if RLS is enabled on this table
+	*/
+	isRlsEnabled() {
+		return this[EnableRLS];
+	}
+	/**
+	* Internal: add foreign key metadata for runtime enforcement
+	*/
+	addForeignKey(definition) {
+		const matches = (existing) => {
+			if (existing.foreignTableName !== definition.foreignTableName) return false;
+			if (existing.columns.length !== definition.columns.length) return false;
+			if (existing.foreignColumns.length !== definition.foreignColumns.length) return false;
+			for (let i = 0; i < existing.columns.length; i++) if (existing.columns[i] !== definition.columns[i]) return false;
+			for (let i = 0; i < existing.foreignColumns.length; i++) if (existing.foreignColumns[i] !== definition.foreignColumns[i]) return false;
+			return true;
+		};
+		this.foreignKeys = this.foreignKeys.filter((existing) => !matches(existing));
+		this.foreignKeys.push(definition);
+	}
+	resolveDeferredForeignKeys() {
+		if (this.deferredForeignKeysResolved) return;
+		this.deferredForeignKeysResolved = true;
+		for (const deferred of this.deferredForeignKeys) {
+			let foreignColumn;
+			try {
+				foreignColumn = deferred.ref();
+			} catch (error) {
+				const reason = error instanceof Error ? ` ${error.message}` : "";
+				throw new Error(`Failed to resolve foreign key reference for '${this.tableName}.${deferred.localColumnName}'. Use references(() => targetTable.column) after both tables are declared.${reason}`);
+			}
+			const foreignTableName = getColumnTableName(foreignColumn);
+			if (!foreignTableName) throw new Error(`Foreign key on '${this.tableName}.${deferred.localColumnName}' references a column without a table. Use references(() => targetTable.column).`);
+			const foreignTable = getColumnTable(foreignColumn);
+			if (!foreignTable) throw new Error(`Foreign key on '${this.tableName}.${deferred.localColumnName}' references a column without table metadata. Replace references(() => id('tableName')) with references(() => table.id).`);
+			const foreignColumnName = getColumnName(foreignColumn);
+			this.addForeignKey({
+				name: deferred.config.name,
+				columns: [deferred.localColumnName],
+				foreignTableName,
+				foreignTable,
+				foreignColumns: [foreignColumnName],
+				onDelete: deferred.config.onDelete,
+				onUpdate: deferred.config.onUpdate
+			});
+		}
+		this.deferredForeignKeys = [];
+	}
+	/**
+	* Internal: expose foreign key metadata for mutation enforcement
+	*/
+	getForeignKeys() {
+		this.resolveDeferredForeignKeys();
+		return this.foreignKeys;
+	}
+	addCheck(name, expression) {
+		this.checks.push({
+			name,
+			expression
+		});
+	}
+	getChecks() {
+		return this.checks;
+	}
+	/**
+	* Internal: add search index to table from builder extraConfig
+	*/
+	addSearchIndex(name, config) {
+		const entry = {
+			indexDescriptor: name,
+			searchField: config.searchField,
+			filterFields: config.filterFields ?? []
+		};
+		if (config.staged) this.stagedSearchIndexes.push(entry);
+		else this.searchIndexes.push(entry);
+	}
+	/**
+	* Internal: add vector index to table from builder extraConfig
+	*/
+	addVectorIndex(name, config) {
+		const entry = {
+			indexDescriptor: name,
+			vectorField: config.vectorField,
+			dimensions: config.dimensions,
+			filterFields: config.filterFields ?? []
+		};
+		if (config.staged) this.stagedVectorIndexes.push(entry);
+		else this.vectorIndexes.push(entry);
+	}
+	/**
+	* Export the contents of this definition for Convex schema tooling.
+	* Mirrors convex/server TableDefinition.export().
+	*/
+	export() {
+		const documentType = this.validator.json;
+		if (typeof documentType !== "object") throw new Error("Invalid validator: please make sure that the parameter of `defineTable` is valid (see https://docs.convex.dev/database/schemas)");
+		return {
+			indexes: this.indexes,
+			stagedDbIndexes: this.stagedDbIndexes,
+			searchIndexes: this.searchIndexes,
+			stagedSearchIndexes: this.stagedSearchIndexes,
+			vectorIndexes: this.vectorIndexes,
+			stagedVectorIndexes: this.stagedVectorIndexes,
+			documentType
+		};
+	}
+};
+const convexTableInternal = (name, columns, extraConfig) => {
+	const expanded = resolveTableColumns(name, columns);
+	const rawTable = new ConvexTableImpl(name, expanded.columns, expanded.polymorphicConfigs);
+	const systemFields = createSystemFields(name);
+	for (const builder of Object.values(systemFields)) builder.config.table = rawTable;
+	const table = Object.assign(rawTable, systemFields, rawTable[Columns]);
+	const internalCreationTime = systemFields._creationTime;
+	if (Object.hasOwn(table, "_creationTime")) table._creationTime = void 0;
+	Object.defineProperty(table, "_creationTime", {
+		value: internalCreationTime,
+		enumerable: false,
+		configurable: true,
+		writable: false
+	});
+	Object.defineProperty(table, "_id", {
+		value: systemFields.id,
+		enumerable: false,
+		configurable: true,
+		writable: false
+	});
+	applyExtraConfig(rawTable, extraConfig?.(table));
+	return table;
+};
+const convexTableWithRLS = (name, columns, extraConfig) => {
+	const table = convexTableInternal(name, columns, extraConfig);
+	table[EnableRLS] = true;
+	return table;
+};
+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 { vectorIndex as A, ConvexColumnBuilder as B, RlsPolicy as C, rankIndex as D, index as E, arrayOf as F, custom as I, json as L, createSystemFields as M, integer as N, searchIndex as O, id as P, objectOf as R, TablePolymorphic as S, aggregateIndex as T, entityKind as V, OrmSchemaRelations as _, deletion as a, TableDeleteConfig as b, Columns as c, OrmSchemaDefinition as d, OrmSchemaExtensionRelations as f, OrmSchemaOptions as g, OrmSchemaExtensions as h, convexTable as i, text as j, uniqueIndex as k, EnableRLS as l, OrmSchemaExtensionTriggers as m, TableAggregate as n, discriminator as o, OrmSchemaExtensionTables as p, aggregateStorageTables as r, Brand as s, DirectAggregate as t, OrmContext as u, OrmSchemaTriggers as v, rlsPolicy as w, TableName as x, RlsPolicies as y, unionOf as z };