kitcn 0.23.0 → 0.25.0

package/dist/orm/index.js

@@ -1,6 +1,11 @@
-import { A as vectorIndex, B as ConvexColumnBuilder, C as RlsPolicy, D as rankIndex, E as index, F as arrayOf, I as custom, L as json, M as createSystemFields, N as integer, O as searchIndex, P as id, R as objectOf, S as TablePolymorphic, T as aggregateIndex, V as entityKind, _ as OrmSchemaRelations, a as deletion, b as TableDeleteConfig, c as Columns, d as OrmSchemaDefinition, f as OrmSchemaExtensionRelations, g as OrmSchemaOptions, h as OrmSchemaExtensions, i as convexTable, j as text, k as uniqueIndex, l as EnableRLS, m as OrmSchemaExtensionTriggers, o as discriminator, p as OrmSchemaExtensionTables, s as Brand, t as DirectAggregate, u as OrmContext, v as OrmSchemaTriggers, w as rlsPolicy, x as TableName, y as RlsPolicies, z as unionOf } from "../runtime-6DJxpDfb.js";
-import { a as pretendRequired, i as pretend, n as deprecated } from "../validators-C7LelqTN.js";
-import { A as like, B as or, C as gt, D as isFieldReference, E as inArray, F as not, I as notBetween, L as notIlike, M as lte, N as matchLikePattern, O as isNotNull, P as ne, R as notInArray, S as filterValuesEqual, T as ilike, V as startsWith, _ as contains, a as indexKeyWithinBounds, b as fieldRef, c as streamIndexRange, d as and, f as arrayContained, g as column, h as between, i as getIndexFields, j as lt, k as isNull, l as isUnsetToken, m as arrayOverlaps, n as EmptyStream, o as mergedStream, p as arrayContains, r as QueryStream, s as stream, t as getByIdWithOrmQueryFallback, u as unsetToken, v as endsWith, w as gte, x as filterValueInList, y as eq, z as notLike } from "../query-context-BzihIpnM.js";
+import { A as integer, C as index, D as vectorIndex, E as uniqueIndex, F as unionOf, I as ConvexColumnBuilder, L as entityKind, M as custom, N as json, O as text, P as objectOf, S as aggregateIndex, T as searchIndex, a as Columns, b as RlsPolicy, c as OrmSchemaDefinition, d as OrmSchemaExtensionTriggers, f as OrmSchemaExtensions, g as RlsPolicies, h as OrmSchemaTriggers, i as Brand, j as arrayOf, k as createSystemFields, l as OrmSchemaExtensionRelations, m as OrmSchemaRelations, n as deletion, o as EnableRLS, p as OrmSchemaOptions, r as discriminator, s as OrmContext, t as convexTable, u as OrmSchemaExtensionTables, v as TableName, w as rankIndex, x as rlsPolicy, y as TablePolymorphic } from "../table-rmJm5Qio.js";
+import { d as boolean, i as detectMigrationDrift, l as migrationExtension, n as defineMigration, r as defineMigrationSet, t as buildMigrationPlan } from "../definitions-D9vhJ6OV.js";
+import { a as pretendRequired, i as pretend, n as deprecated } from "../validators-Dmbhsd3U.js";
+import { t as id } from "../id-Bibg34Yb.js";
+import { A as or, C as matchLikePattern, D as notIlike, E as notBetween, O as notInArray, S as lte, T as not, _ as isFieldReference, a as between, b as like, c as endsWith, d as filterValueInList, f as filterValuesEqual, g as inArray, h as ilike, i as arrayOverlaps, j as startsWith, k as notLike, l as eq, m as gte, n as arrayContained, o as column, p as gt, r as arrayContains, s as contains, t as and, u as fieldRef, v as isNotNull, w as ne, x as lt, y as isNull } from "../filter-expression-Dydt8wS0.js";
+import { a as indexKeyWithinBounds, c as streamIndexRange, i as getIndexFields, l as isUnsetToken, n as EmptyStream, o as mergedStream, r as QueryStream, s as stream, t as getByIdWithOrmQueryFallback, u as unsetToken } from "../query-context-DOm5Xm3H.js";
+import { $ as serializeFilterExpression, A as ensureNonNullValues, B as getMutationExecutionMode, C as deserializeFilterExpression, D as enforcePolymorphicWrite, E as enforceForeignKeys, F as getChecks, G as getUniqueIndexes, H as getTableColumns$2, I as getColumnName$1, J as normalizeDateFieldsForWrite, K as hardDeleteRow, L as getForeignKeys, M as evaluateCheckConstraintTriState, N as evaluateFilter, O as enforceUniqueIndexes, P as extractPrimaryIdLookup, Q as selectReturningRowWithHydration, R as getMutationAsyncDelayMs, S as decodeUndefinedDeep, T as enforceCheckConstraints, U as getTableDeleteConfig, V as getOrmContext, W as getTableName, X as patchReferencingRows, Y as normalizeTemporalComparableValue, Z as resolveOrmRuntimeDefaults, _ as applyIncomingForeignKeyActionsOnUpdate, _t as usesSystemCreatedAtAlias, a as aggregateExtension, at as markLifecycleHookedTables, b as collectMutationRowsBounded, c as AGGREGATE_ERROR, ct as findSearchIndexByName, d as createCountError, dt as getIndexes, et as softDeleteRow, ft as getRankIndexes, g as applyIncomingForeignKeyActionsOnDelete, gt as PUBLIC_CREATED_AT_FIELD, h as applyDefaults, ht as INTERNAL_CREATION_TIME_FIELD, it as mapWithConcurrency, j as ensureNullableColumns, k as ensureDefaultColumns, l as COUNT_ERROR, lt as findVectorIndexByName, m as ensureCountAllowedForRls, mt as CREATED_AT_MIGRATION_MESSAGE, nt as takeRowsWithinByteBudget, o as getAggregateIndexDefinitions, ot as findIndexForColumns, p as ensureAggregateAllowedForRls, pt as resolveIndexOrderPushdown, q as hydrateDateFieldsForRead, rt as toConvexFilter, s as getRankIndexDefinitions, st as findRelationIndex, tt as splitReturningSelection, u as createAggregateError, ut as getAggregateIndexes, v as buildForeignKeyGraph, w as encodeUndefinedDeep, x as collectPrimaryIdLookupRows, y as canUsePrimaryIdLookupCursor, z as getMutationCollectionLimits } from "../schema-Besl-rpv.js";
+import { t as defineSchemaExtension } from "../extensions-DzjCJXYl.js";
 import { compareValues, v } from "convex/values";
 import { defineSchema as defineSchema$1, internalActionGeneric, internalMutationGeneric } from "convex/server";
 
@@ -34,37 +39,6 @@ function bigint(name) {
 	return new ConvexBigIntBuilder(name ?? "");
 }
 
-//#endregion
-//#region src/orm/builders/boolean.ts
-/**
-* Boolean column builder class
-* Compiles to v.boolean() or v.optional(v.boolean())
-*/
-var ConvexBooleanBuilder = class extends ConvexColumnBuilder {
-	static [entityKind] = "ConvexBooleanBuilder";
-	constructor(name) {
-		super(name, "boolean", "ConvexBoolean");
-	}
-	/**
-	* Expose Convex validator for schema integration
-	*/
-	get convexValidator() {
-		if (this.config.notNull) return v.boolean();
-		return v.optional(v.union(v.null(), v.boolean()));
-	}
-	/**
-	* Compile to Convex validator
-	* .notNull() → v.boolean()
-	* nullable → v.optional(v.boolean())
-	*/
-	build() {
-		return this.convexValidator;
-	}
-};
-function boolean(name) {
-	return new ConvexBooleanBuilder(name ?? "");
-}
-
 //#endregion
 //#region src/orm/builders/bytes.ts
 var ConvexBytesBuilder = class extends ConvexColumnBuilder {
@@ -280,3548 +254,41 @@ var ConvexCheckBuilder = class {
 	[entityKind] = "ConvexCheckBuilder";
 	config;
 	constructor(name, expression) {
-		this.config = {
-			name,
-			expression
-		};
-	}
-};
-function check(name, expression) {
-	return new ConvexCheckBuilder(name, expression);
-}
-
-//#endregion
-//#region src/orm/timestamp-mode.ts
-const PUBLIC_CREATED_AT_FIELD = "createdAt";
-const INTERNAL_CREATION_TIME_FIELD = "_creationTime";
-const CREATED_AT_MIGRATION_MESSAGE = "`_creationTime` is no longer public. Use `createdAt` instead.";
-const hasUserCreatedAtColumn = (table) => {
-	if (!table || typeof table !== "object") return false;
-	const columns = table[Columns];
-	if (!columns || typeof columns !== "object") return false;
-	return Object.hasOwn(columns, PUBLIC_CREATED_AT_FIELD);
-};
-const usesSystemCreatedAtAlias = (_table) => true;
-
-//#endregion
-//#region src/orm/index-utils.ts
-function getIndexes(table) {
-	const indexes = table.getIndexes?.();
-	return Array.isArray(indexes) ? indexes : [];
-}
-function getAggregateIndexes(table) {
-	const indexes = table.getAggregateIndexes?.();
-	return Array.isArray(indexes) ? indexes : [];
-}
-function getRankIndexes(table) {
-	const indexes = table.getRankIndexes?.();
-	return Array.isArray(indexes) ? indexes : [];
-}
-function getSearchIndexes(table) {
-	const indexes = table.getSearchIndexes?.();
-	return Array.isArray(indexes) ? indexes : [];
-}
-function findSearchIndexByName(table, indexName) {
-	return getSearchIndexes(table).find((index) => index.name === indexName) ?? null;
-}
-function getVectorIndexes(table) {
-	const indexes = table.getVectorIndexes?.();
-	return Array.isArray(indexes) ? indexes : [];
-}
-function findVectorIndexByName(table, indexName) {
-	return getVectorIndexes(table).find((index) => index.name === indexName) ?? null;
-}
-function findIndexForColumns(indexes, columns) {
-	for (const index of indexes) if (hasColumnPrefix(index, columns)) return index.name;
-	return null;
-}
-const hasColumnPrefix = (index, columns) => {
-	if (index.fields.length < columns.length) return false;
-	for (let i = 0; i < columns.length; i += 1) if (index.fields[i] !== columns[i]) return false;
-	return true;
-};
-/**
-* Answers "does scanning this index already produce the requested order?".
-*
-* Convex walks an index in full key order, so once a leading run of fields is
-* pinned to a single value by `eq`, the remainder of the scan is already sorted
-* by the next index field — and by `_creationTime` once every declared field is
-* pinned, because Convex appends it as the implicit trailing key. When that
-* field is the one the caller asked to sort by, `.order(dir).take(n)` returns
-* the exact page and nothing has to be collected and sorted afterwards.
-*
-* This is the single owner of that decision. The top-level query planner and
-* the relation loader both call it, so a bound one of them can push into the
-* index can never be one the other silently drops.
-*
-* Returns the direction to hand to `.order()`, or null when the sort must run
-* after the fetch.
-*/
-function resolveIndexOrderPushdown(params) {
-	const { indexFields, pinnedEqCount, orderSpecs } = params;
-	if (!indexFields || orderSpecs.length !== 1) return null;
-	const primary = orderSpecs[0];
-	const eqCount = Math.min(Math.max(pinnedEqCount, 0), indexFields.length);
-	for (let i = 0; i < eqCount; i += 1) if (indexFields[i] === primary.field) return primary.direction;
-	const nativeField = eqCount >= indexFields.length ? INTERNAL_CREATION_TIME_FIELD : indexFields[eqCount];
-	return primary.field === nativeField ? primary.direction : null;
-}
-function findRelationIndex(table, columns, relationName, targetTableName, strict = true, allowFullScan = false, orderSpecs = []) {
-	const indexes = getIndexes(table);
-	const fallbackIndex = findIndexForColumns(indexes, columns);
-	const index = (orderSpecs.length === 0 ? void 0 : indexes.find((candidate) => hasColumnPrefix(candidate, columns) && resolveIndexOrderPushdown({
-		indexFields: candidate.fields,
-		pinnedEqCount: columns.length,
-		orderSpecs
-	}) !== null))?.name ?? fallbackIndex;
-	if (!index && !allowFullScan) throw new Error(`Relation ${relationName} requires index on '${targetTableName}(${columns.join(", ")})'. Set allowFullScan: true to override.`);
-	if (!index && strict) console.warn(`Relation ${relationName} running without index (allowFullScan: true).`);
-	return index;
-}
-
-//#endregion
-//#region src/orm/write-fanout.ts
-/**
-* Shared primitives for fanning out independent writes.
-*
-* Deliberately dependency-free: `mutation-utils`, `lifecycle` and `query` all
-* import it, and Convex bundles every static import of a function entry.
-*/
-const ORMLIFECYCLE_HOOKED_TABLES = Symbol.for("kitcn:OrmLifecycleHookedTables");
-/** Matches the ORM's relation-loading default. */
-const DEFAULT_WRITE_FANOUT_CONCURRENCY = 25;
-/**
-* Runs `worker` over `items` with at most `limit` in flight. Results keep input
-* order. Unbounded `Promise.all` is not an option here: a fan-out is bounded
-* only by `mutationMaxRows` (10,000), and that many simultaneous in-flight
-* syscalls is its own failure mode.
-*/
-async function mapWithConcurrency(items, limit, worker) {
-	if (items.length === 0) return [];
-	const width = Math.max(1, Math.min(limit, items.length));
-	const results = new Array(items.length);
-	let nextIndex = 0;
-	const runWorker = async () => {
-		while (true) {
-			const index = nextIndex;
-			nextIndex += 1;
-			if (index >= items.length) return;
-			results[index] = await worker(items[index], index);
-		}
-	};
-	await Promise.all(Array.from({ length: width }, () => runWorker()));
-	return results;
-}
-/**
-* Records which tables the lifecycle writer intercepts, so write fan-out can
-* see it without importing `lifecycle` (which would close an import cycle
-* through `aggregate-index/runtime`).
-*/
-const markLifecycleHookedTables = (db, tableNames) => {
-	Object.defineProperty(db, ORMLIFECYCLE_HOOKED_TABLES, {
-		configurable: false,
-		enumerable: false,
-		value: tableNames,
-		writable: false
-	});
-	return db;
-};
-/**
-* True when writes to `tableName` run through trigger / aggregate-index hooks.
-* Those writes are serialized by the lifecycle write lock and their hooks fire
-* in write order, so they must keep their sequential loop; everything else is
-* free to fan out.
-*/
-const hasLifecycleHooks = (db, tableName) => {
-	return (db?.[ORMLIFECYCLE_HOOKED_TABLES])?.has(tableName) ?? false;
-};
-
-//#endregion
-//#region src/orm/mutation-utils.ts
-const UNDEFINED_SENTINEL_KEY = "__kitcnUndefined";
-const INTERNAL_ID_FIELD$2 = "_id";
-const PUBLIC_ID_FIELD$2 = "id";
-const DATE_COLUMN_TYPE = "ConvexDate";
-const TIMESTAMP_COLUMN_TYPE = "ConvexTimestamp";
-const isPlainObject$1 = (value) => !!value && typeof value === "object" && !Array.isArray(value);
-const temporalColumnDescriptorCache = /* @__PURE__ */ new WeakMap();
-const DATE_ONLY_REGEX = /^\d{4}-\d{2}-\d{2}$/;
-const toDateOnlyString = (value) => value.toISOString().slice(0, 10);
-const toDateOnlyDate = (value) => DATE_ONLY_REGEX.test(value) ? /* @__PURE__ */ new Date(`${value}T00:00:00.000Z`) : value;
-const toTimestampMillis = (value) => {
-	if (value instanceof Date) return value.getTime();
-	if (typeof value === "string") {
-		const parsed = Date.parse(value);
-		if (!Number.isNaN(parsed)) return parsed;
-	}
-	return value;
-};
-const readTimestampValue = (value, mode) => {
-	if (mode === "date" && typeof value === "number") return new Date(value);
-	if (mode === "string" && typeof value === "number") return new Date(value).toISOString();
-	return value;
-};
-const getTemporalDescriptorFromColumn = (name, column) => {
-	const config = column?.config;
-	const columnType = config?.columnType;
-	if (columnType !== DATE_COLUMN_TYPE && columnType !== TIMESTAMP_COLUMN_TYPE) return;
-	if (columnType === DATE_COLUMN_TYPE) return {
-		name,
-		columnType,
-		mode: config?.mode === "date" ? "date" : "string"
-	};
-	return {
-		name,
-		columnType,
-		mode: config?.mode === "string" ? "string" : "date"
-	};
-};
-const getTemporalColumnDescriptors = (table) => {
-	const cacheKey = table;
-	const cached = temporalColumnDescriptorCache.get(cacheKey);
-	if (cached) return cached;
-	const descriptors = /* @__PURE__ */ new Map();
-	for (const [name, column] of Object.entries(getTableColumns$2(table))) {
-		const descriptor = getTemporalDescriptorFromColumn(name, column);
-		if (!descriptor) continue;
-		descriptors.set(name, descriptor);
-	}
-	temporalColumnDescriptorCache.set(cacheKey, descriptors);
-	return descriptors;
-};
-const getTemporalColumnDescriptor = (table, columnName) => {
-	const temporalColumns = getTemporalColumnDescriptors(table);
-	const direct = temporalColumns.get(columnName);
-	if (direct) return direct;
-	const columns = getTableColumns$2(table);
-	for (const descriptor of temporalColumns.values()) if (columns[descriptor.name]?.config?.name === columnName) return descriptor;
-};
-const normalizeTemporalWriteValue = (descriptor, value) => {
-	if (descriptor.columnType === DATE_COLUMN_TYPE) {
-		if (value instanceof Date) return toDateOnlyString(value);
-		return value;
-	}
-	return toTimestampMillis(value);
-};
-const hydrateTemporalReadValue = (descriptor, value) => {
-	if (descriptor.columnType === DATE_COLUMN_TYPE) {
-		if (descriptor.mode === "date" && typeof value === "string") return toDateOnlyDate(value);
-		return value;
-	}
-	return readTimestampValue(value, descriptor.mode);
-};
-const normalizeTemporalComparableValue = (table, fieldName, value) => {
-	const descriptor = getTemporalColumnDescriptor(table, fieldName);
-	if (!descriptor) return value;
-	if (Array.isArray(value)) return value.map((entry) => normalizeTemporalWriteValue(descriptor, entry));
-	return normalizeTemporalWriteValue(descriptor, value);
-};
-const normalizeDateFieldsForWrite = (table, value) => {
-	const useSystemCreatedAt = usesSystemCreatedAtAlias(table);
-	const hasUserCreatedAt = hasUserCreatedAtColumn(table);
-	const temporalColumns = getTemporalColumnDescriptors(table);
-	const result = { ...value };
-	if (Object.hasOwn(result, INTERNAL_CREATION_TIME_FIELD)) throw new Error(CREATED_AT_MIGRATION_MESSAGE);
-	if (useSystemCreatedAt && !hasUserCreatedAt && Object.hasOwn(result, PUBLIC_CREATED_AT_FIELD)) delete result[PUBLIC_CREATED_AT_FIELD];
-	for (const [name, descriptor] of temporalColumns.entries()) {
-		if (!Object.hasOwn(result, name)) continue;
-		result[name] = normalizeTemporalWriteValue(descriptor, result[name]);
-	}
-	return result;
-};
-/**
-* Reshapes a stored document into its public form in a single pass: renames
-* `_id` to `id`, aliases `_creationTime` to `createdAt`, and hydrates temporal
-* columns. Deliberately allocates exactly one object and never calls `delete`
-* on it — deleting an existing own property drops the object into V8
-* dictionary mode, which then poisons every downstream spread.
-*/
-const hydrateDateFieldsForRead = (table, value) => {
-	if (!isPlainObject$1(value)) return value;
-	const obj = value;
-	const hasId = Object.hasOwn(obj, INTERNAL_ID_FIELD$2);
-	const rawCreationTime = obj[INTERNAL_CREATION_TIME_FIELD];
-	const aliasCreatedAt = usesSystemCreatedAtAlias(table) && Object.hasOwn(obj, INTERNAL_CREATION_TIME_FIELD) && rawCreationTime !== void 0;
-	const temporalColumns = getTemporalColumnDescriptors(table);
-	const result = {};
-	for (const key of Object.keys(obj)) {
-		if (key === INTERNAL_ID_FIELD$2 || key === INTERNAL_CREATION_TIME_FIELD) continue;
-		if (key === PUBLIC_CREATED_AT_FIELD && aliasCreatedAt) {
-			result[key] = void 0;
-			continue;
-		}
-		const descriptor = temporalColumns.get(key);
-		result[key] = descriptor ? hydrateTemporalReadValue(descriptor, obj[key]) : obj[key];
-	}
-	if (hasId) result[PUBLIC_ID_FIELD$2] = obj[INTERNAL_ID_FIELD$2];
-	if (aliasCreatedAt) {
-		const descriptor = temporalColumns.get(PUBLIC_CREATED_AT_FIELD);
-		result[PUBLIC_CREATED_AT_FIELD] = descriptor ? hydrateTemporalReadValue(descriptor, rawCreationTime) : rawCreationTime;
-	}
-	return result;
-};
-const selectReturningRowWithHydration = (table, row, fields) => {
-	const useSystemCreatedAt = usesSystemCreatedAtAlias(table);
-	const temporalColumns = getTemporalColumnDescriptors(table);
-	const selected = {};
-	for (const [selectedKey, column] of Object.entries(fields)) {
-		const columnName = getSelectionColumnName(column);
-		let value = row[columnName];
-		if (!(columnName === INTERNAL_CREATION_TIME_FIELD && useSystemCreatedAt)) {
-			const descriptor = temporalColumns.get(columnName);
-			if (descriptor) value = hydrateTemporalReadValue(descriptor, value);
-		}
-		selected[selectedKey] = value;
-	}
-	return { ...selected };
-};
-const encodeUndefinedDeep = (value) => {
-	if (value === void 0) return { [UNDEFINED_SENTINEL_KEY]: true };
-	if (Array.isArray(value)) return value.map((item) => encodeUndefinedDeep(item));
-	if (isPlainObject$1(value)) {
-		const result = {};
-		for (const [key, nested] of Object.entries(value)) result[key] = encodeUndefinedDeep(nested);
-		return result;
-	}
-	return value;
-};
-const decodeUndefinedDeep = (value) => {
-	if (Array.isArray(value)) return value.map((item) => decodeUndefinedDeep(item));
-	if (isPlainObject$1(value)) {
-		if (Object.keys(value).length === 1 && value[UNDEFINED_SENTINEL_KEY] === true) return;
-		const result = {};
-		for (const [key, nested] of Object.entries(value)) result[key] = decodeUndefinedDeep(nested);
-		return result;
-	}
-	return value;
-};
-const isSerializedFieldReference = (value) => isPlainObject$1(value) && typeof value.fieldName === "string";
-const createBinaryExpression = (operator, fieldName, value) => {
-	return {
-		type: "binary",
-		operator,
-		operands: [fieldRef(fieldName), value],
-		accept(visitor) {
-			return visitor.visitBinary(this);
-		}
-	};
-};
-const createLogicalExpression = (operator, operands) => ({
-	type: "logical",
-	operator,
-	operands,
-	accept(visitor) {
-		return visitor.visitLogical(this);
-	}
-});
-const createUnaryExpression = (operator, operand) => ({
-	type: "unary",
-	operator,
-	operands: [operand],
-	accept(visitor) {
-		return visitor.visitUnary(this);
-	}
-});
-const serializeFilterExpression = (expression) => {
-	if (!expression) return;
-	if (expression.type === "binary") {
-		const binary = expression;
-		const [field, value] = binary.operands;
-		if (!isFieldReference(field)) throw new Error("Binary expression must have FieldReference as first operand");
-		return {
-			type: "binary",
-			operator: binary.operator,
-			field: { fieldName: field.fieldName },
-			value: encodeUndefinedDeep(value)
-		};
-	}
-	if (expression.type === "logical") {
-		const logical = expression;
-		return {
-			type: "logical",
-			operator: logical.operator,
-			operands: logical.operands.map((operand) => serializeFilterExpression(operand))
-		};
-	}
-	const unary = expression;
-	const [operand] = unary.operands;
-	return {
-		type: "unary",
-		operator: unary.operator,
-		operand: isFieldReference(operand) ? { fieldName: operand.fieldName } : serializeFilterExpression(operand)
-	};
-};
-const deserializeFilterExpression = (expression) => {
-	if (!expression) return;
-	if (expression.type === "binary") {
-		const binary = expression;
-		return createBinaryExpression(binary.operator, binary.field.fieldName, decodeUndefinedDeep(binary.value));
-	}
-	if (expression.type === "logical") {
-		const logical = expression;
-		return createLogicalExpression(logical.operator, logical.operands.map((operand) => deserializeFilterExpression(operand)).filter((operand) => !!operand));
-	}
-	const unary = expression;
-	const operand = unary.operand;
-	if (isSerializedFieldReference(operand)) return createUnaryExpression(unary.operator, fieldRef(operand.fieldName));
-	const nested = deserializeFilterExpression(operand);
-	if (!nested) throw new Error("Serialized unary operand is missing.");
-	return createUnaryExpression(unary.operator, nested);
-};
-const PRIMARY_ID_LOOKUP_CURSOR_PREFIX = "kitcn:primary-id:";
-const dedupePrimaryIds = (values) => Array.from(new Map(values.map((value) => [String(value), value])).values());
-const parsePrimaryIdLookupCursor = (cursor) => {
-	if (cursor === null) return 0;
-	if (!cursor.startsWith(PRIMARY_ID_LOOKUP_CURSOR_PREFIX)) throw new Error("Invalid primary id mutation cursor.");
-	const offset = Number(cursor.slice(17));
-	if (!Number.isInteger(offset) || offset < 0) throw new Error("Invalid primary id mutation cursor.");
-	return offset;
-};
-const canUsePrimaryIdLookupCursor = (cursor) => cursor === null || cursor === void 0 || cursor.startsWith(PRIMARY_ID_LOOKUP_CURSOR_PREFIX);
-const extractPrimaryIdLookup = (expression) => {
-	if (!expression || expression.type !== "binary") return null;
-	const binary = expression;
-	const [left, right] = binary.operands;
-	if (binary.operator === "eq") {
-		if (isFieldReference(left) && left.fieldName === "_id") {
-			if (isFieldReference(right)) return null;
-			return {
-				kind: "eq",
-				values: [right]
-			};
-		}
-		if (isFieldReference(right) && right.fieldName === "_id") {
-			if (isFieldReference(left)) return null;
-			return {
-				kind: "eq",
-				values: [left]
-			};
-		}
-	}
-	if (binary.operator === "inArray" && isFieldReference(left) && left.fieldName === "_id" && Array.isArray(right)) return {
-		kind: "in",
-		values: dedupePrimaryIds(right)
-	};
-	return null;
-};
-const windowPrimaryIdLookup = (lookup, pagination) => {
-	if (!pagination) return {
-		continueCursor: null,
-		isDone: true,
-		values: lookup.values
-	};
-	const offset = parsePrimaryIdLookupCursor(pagination.cursor);
-	const nextOffset = offset + pagination.limit;
-	const values = lookup.values.slice(offset, nextOffset);
-	const isDone = nextOffset >= lookup.values.length;
-	return {
-		continueCursor: isDone ? null : `${PRIMARY_ID_LOOKUP_CURSOR_PREFIX}${nextOffset}`,
-		isDone,
-		values
-	};
-};
-const collectPrimaryIdLookupRows = async (db, tableName, lookup, options) => {
-	if (!options.pagination && lookup.values.length > options.maxRows) throw new Error(`${options.operation} exceeded mutationMaxRows (${options.maxRows}) on "${tableName}". Narrow the filter or increase defineSchema(..., { defaults: { mutationMaxRows } }).`);
-	if (!options.pagination && lookup.values.length > options.batchSize) throw new Error(`${options.operation} matched more than mutationBatchSize (${options.batchSize}) primary ids on "${tableName}". Use executeAsync({ batchSize }) or paginate() to split the mutation.`);
-	const primaryIdWindow = windowPrimaryIdLookup(lookup, options.pagination);
-	if (primaryIdWindow.values.length > options.maxRows) throw new Error(`${options.operation} exceeded mutationMaxRows (${options.maxRows}) on "${tableName}". Narrow the filter or increase defineSchema(..., { defaults: { mutationMaxRows } }).`);
-	const normalizedIds = primaryIdWindow.values.filter((value) => value !== null && value !== void 0).map((value) => db.normalizeId(tableName, value)).filter((value) => value !== null);
-	const fetchedRows = await Promise.all(normalizedIds.map((value) => db.get(value)));
-	return {
-		continueCursor: primaryIdWindow.continueCursor,
-		isDone: primaryIdWindow.isDone,
-		rows: fetchedRows.filter((row) => !!row)
-	};
-};
-const DEFAULT_MUTATION_BATCH_SIZE = 400;
-const DEFAULT_MUTATION_LEAF_BATCH_SIZE = 1600;
-const DEFAULT_MUTATION_MAX_ROWS = 1e4;
-const DEFAULT_MUTATION_MAX_BYTES_PER_BATCH = 2097152;
-const DEFAULT_MUTATION_SCHEDULE_CALL_CAP = 800;
-const DEFAULT_MUTATION_ASYNC_DELAY_MS = 0;
-const DEFAULT_COUNT_BACKFILL_BATCH_SIZE = 1e3;
-const DEFAULT_RELATION_FAN_OUT_MAX_KEYS$1 = 1e3;
-const DEFAULT_AGGREGATE_CARTESIAN_MAX_KEYS$2 = 4096;
-const DEFAULT_AGGREGATE_WORK_BUDGET$2 = 16384;
-const MEASURED_BYTE_SAFETY_MULTIPLIER = 2;
-const UTF8_LENGTH_THRESHOLD = 500;
-const UTF8_ENCODER = new TextEncoder();
-const getUtf8ByteLength = (value) => {
-	if (value.length > UTF8_LENGTH_THRESHOLD) return UTF8_ENCODER.encode(value).length;
-	let bytes = 0;
-	for (let i = 0; i < value.length; i++) {
-		const code = value.charCodeAt(i);
-		if (code < 128) bytes += 1;
-		else if (code < 2048) bytes += 2;
-		else if (code >= 55296 && code <= 56319) {
-			bytes += 4;
-			i += 1;
-		} else bytes += 3;
-	}
-	return bytes;
-};
-const resolveOrmRuntimeDefaults = (defaults, runtime = {}) => {
-	const inferredMode = runtime.scheduler && runtime.scheduledMutationBatch ? "async" : "sync";
-	return {
-		defaultLimit: defaults?.defaultLimit,
-		countBackfillBatchSize: defaults?.countBackfillBatchSize ?? DEFAULT_COUNT_BACKFILL_BATCH_SIZE,
-		relationFanOutMaxKeys: defaults?.relationFanOutMaxKeys ?? DEFAULT_RELATION_FAN_OUT_MAX_KEYS$1,
-		aggregateCartesianMaxKeys: defaults?.aggregateCartesianMaxKeys ?? DEFAULT_AGGREGATE_CARTESIAN_MAX_KEYS$2,
-		aggregateWorkBudget: defaults?.aggregateWorkBudget ?? DEFAULT_AGGREGATE_WORK_BUDGET$2,
-		mutationBatchSize: defaults?.mutationBatchSize ?? DEFAULT_MUTATION_BATCH_SIZE,
-		mutationLeafBatchSize: defaults?.mutationLeafBatchSize ?? DEFAULT_MUTATION_LEAF_BATCH_SIZE,
-		mutationMaxRows: defaults?.mutationMaxRows ?? DEFAULT_MUTATION_MAX_ROWS,
-		mutationMaxBytesPerBatch: defaults?.mutationMaxBytesPerBatch ?? DEFAULT_MUTATION_MAX_BYTES_PER_BATCH,
-		mutationScheduleCallCap: defaults?.mutationScheduleCallCap ?? DEFAULT_MUTATION_SCHEDULE_CALL_CAP,
-		mutationExecutionMode: defaults?.mutationExecutionMode ?? inferredMode,
-		mutationAsyncDelayMs: defaults?.mutationAsyncDelayMs ?? DEFAULT_MUTATION_ASYNC_DELAY_MS
-	};
-};
-const estimateMeasuredMutationRowBytes = (row) => {
-	return getUtf8ByteLength(JSON.stringify(row)) * MEASURED_BYTE_SAFETY_MULTIPLIER;
-};
-const takeRowsWithinByteBudget = (rows, maxBytesPerBatch) => {
-	if (!Number.isInteger(maxBytesPerBatch) || maxBytesPerBatch < 1) throw new Error("mutationMaxBytesPerBatch must be a positive integer.");
-	if (rows.length === 0) return {
-		rows,
-		hitLimit: false
-	};
-	let bytes = 0;
-	const selected = [];
-	for (const row of rows) {
-		const rowBytes = estimateMeasuredMutationRowBytes(row);
-		if (selected.length > 0 && bytes + rowBytes > maxBytesPerBatch) return {
-			rows: selected,
-			hitLimit: true
-		};
-		selected.push(row);
-		bytes += rowBytes;
-	}
-	return {
-		rows: selected,
-		hitLimit: false
-	};
-};
-const getMutationCollectionLimits = (context) => {
-	const defaults = context?.resolvedDefaults ?? context?.defaults;
-	const batchSize = defaults?.mutationBatchSize ?? DEFAULT_MUTATION_BATCH_SIZE;
-	const leafBatchSize = defaults?.mutationLeafBatchSize ?? DEFAULT_MUTATION_LEAF_BATCH_SIZE;
-	const maxRows = defaults?.mutationMaxRows ?? DEFAULT_MUTATION_MAX_ROWS;
-	const maxBytesPerBatch = defaults?.mutationMaxBytesPerBatch ?? DEFAULT_MUTATION_MAX_BYTES_PER_BATCH;
-	const scheduleCallCap = defaults?.mutationScheduleCallCap ?? DEFAULT_MUTATION_SCHEDULE_CALL_CAP;
-	if (!Number.isInteger(batchSize) || batchSize < 1) throw new Error("mutationBatchSize must be a positive integer.");
-	if (!Number.isInteger(leafBatchSize) || leafBatchSize < 1) throw new Error("mutationLeafBatchSize must be a positive integer.");
-	if (!Number.isInteger(maxRows) || maxRows < 1) throw new Error("mutationMaxRows must be a positive integer.");
-	if (!Number.isInteger(maxBytesPerBatch) || maxBytesPerBatch < 1) throw new Error("mutationMaxBytesPerBatch must be a positive integer.");
-	if (!Number.isInteger(scheduleCallCap) || scheduleCallCap < 1) throw new Error("mutationScheduleCallCap must be a positive integer.");
-	return {
-		batchSize,
-		leafBatchSize,
-		maxRows,
-		maxBytesPerBatch,
-		scheduleCallCap
-	};
-};
-const consumeScheduleCall = (state) => {
-	if (!state) return;
-	if (state.remainingCalls < 1) throw new Error(`Async cascade scheduling exceeded mutationScheduleCallCap (${state.callCap}). Increase defineSchema(..., { defaults: { mutationScheduleCallCap } }) or reduce fan-out per mutation.`);
-	state.remainingCalls -= 1;
-};
-const getMutationExecutionMode = (context, override) => {
-	const requestedMode = override ?? context?.resolvedDefaults?.mutationExecutionMode ?? context?.defaults?.mutationExecutionMode;
-	if (requestedMode === "sync") return "sync";
-	if (requestedMode === "async") {
-		if (override === "async") return "async";
-		if (context?.scheduler && context?.scheduledMutationBatch) return "async";
-		return "sync";
-	}
-	if (context?.scheduler && context?.scheduledMutationBatch) return "async";
-	return "sync";
-};
-const getMutationAsyncDelayMs = (context, override) => override ?? context?.resolvedDefaults?.mutationAsyncDelayMs ?? context?.defaults?.mutationAsyncDelayMs ?? DEFAULT_MUTATION_ASYNC_DELAY_MS;
-const collectMutationRowsBounded = async (buildQuery, options) => {
-	const rows = await buildQuery().take(options.maxRows + 1);
-	if (rows.length > options.maxRows) throw new Error(`${options.operation} matched more than ${options.maxRows} rows on "${options.tableName}". Narrow the filter or increase defineSchema(..., { defaults: { mutationMaxRows } }).`);
-	return rows;
-};
-function getTableName(table) {
-	const name = table.tableName ?? table[TableName] ?? table?._?.name;
-	if (!name) throw new Error("Table is missing a name");
-	return name;
-}
-function getTableDeleteConfig(table) {
-	return table[TableDeleteConfig];
-}
-function getUniqueIndexes(table) {
-	const fromMethod = table.getUniqueIndexes?.();
-	if (Array.isArray(fromMethod)) return fromMethod;
-	const fromField = table.uniqueIndexes;
-	return Array.isArray(fromField) ? fromField : [];
-}
-function getChecks(table) {
-	const fromMethod = table.getChecks?.();
-	if (Array.isArray(fromMethod)) return fromMethod;
-	const fromField = table.checks;
-	return Array.isArray(fromField) ? fromField : [];
-}
-function buildForeignKeyGraph(schema) {
-	const tableByName = /* @__PURE__ */ new Map();
-	for (const tableConfig of Object.values(schema)) if (tableConfig?.name && tableConfig.table) tableByName.set(tableConfig.name, tableConfig.table);
-	const incomingByTable = /* @__PURE__ */ new Map();
-	for (const tableConfig of Object.values(schema)) {
-		const sourceTable = tableConfig.table;
-		const sourceTableName = tableConfig.name;
-		const foreignKeys = getForeignKeys(sourceTable);
-		for (const foreignKey of foreignKeys) {
-			const targetTableName = foreignKey.foreignTableName;
-			if (!tableByName.get(targetTableName)) throw new Error(`Foreign key from '${sourceTableName}' references missing table '${targetTableName}'.`);
-			const entry = {
-				sourceTable,
-				sourceTableName,
-				sourceColumns: foreignKey.columns,
-				targetTableName,
-				targetColumns: foreignKey.foreignColumns,
-				onDelete: foreignKey.onDelete,
-				onUpdate: foreignKey.onUpdate
-			};
-			const list = incomingByTable.get(targetTableName) ?? [];
-			list.push(entry);
-			incomingByTable.set(targetTableName, list);
-		}
-	}
-	return { incomingByTable };
-}
-function getOrmContext(db) {
-	return db[OrmContext];
-}
-function getForeignKeys(table) {
-	const fromMethod = table.getForeignKeys?.();
-	if (Array.isArray(fromMethod)) return fromMethod;
-	const fromField = table.foreignKeys;
-	return Array.isArray(fromField) ? fromField : [];
-}
-function getColumnName$1(column) {
-	const name = column.config?.name ?? column?._?.name;
-	if (!name) throw new Error("Column builder is missing a column name");
-	return name;
-}
-function getTableColumns$2(table) {
-	return table[Columns] ?? {};
-}
-function getTablePolymorphicConfigs(table) {
-	const fromMethod = table.getPolymorphicConfigs?.();
-	if (Array.isArray(fromMethod)) return fromMethod;
-	const fromSymbol = table[TablePolymorphic];
-	return Array.isArray(fromSymbol) ? fromSymbol : [];
-}
-function enforcePolymorphicWrite(table, candidate, options) {
-	const configs = getTablePolymorphicConfigs(table);
-	if (configs.length === 0) return;
-	for (const config of configs) {
-		const changedFields = options?.changedFields;
-		const discriminatorChanged = !changedFields || changedFields.has(config.discriminator);
-		const generatedFieldChanged = !changedFields || config.generatedFieldNames.some((fieldName) => changedFields.has(fieldName));
-		if (!discriminatorChanged && !generatedFieldChanged) continue;
-		const discriminatorValue = candidate[config.discriminator];
-		if (typeof discriminatorValue !== "string" || !Object.hasOwn(config.variants, discriminatorValue)) throw new Error(`Invalid discriminator '${config.discriminator}' on '${getTableName(table)}'. Expected one of: ${Object.keys(config.variants).join(", ")}.`);
-		const activeVariant = config.variants[discriminatorValue];
-		if (!activeVariant) throw new Error(`Invalid discriminator '${config.discriminator}' value '${discriminatorValue}' on '${getTableName(table)}'.`);
-		for (const requiredFieldName of activeVariant.requiredFieldNames) {
-			const value = candidate[requiredFieldName];
-			if (value === null || value === void 0) throw new Error(`discriminator branch '${discriminatorValue}' requires '${requiredFieldName}' on '${getTableName(table)}'.`);
-		}
-		const activeFieldSet = new Set(activeVariant.fieldNames);
-		for (const generatedFieldName of config.generatedFieldNames) {
-			if (activeFieldSet.has(generatedFieldName)) continue;
-			const value = candidate[generatedFieldName];
-			if (value !== null && value !== void 0) throw new Error(`discriminator branch '${discriminatorValue}' cannot set '${generatedFieldName}' on '${getTableName(table)}' because it belongs to another variant.`);
-		}
-	}
-}
-function getColumnConfig(table, columnName) {
-	const builder = getTableColumns$2(table)[columnName];
-	if (!builder) return null;
-	return builder.config ?? null;
-}
-function applyDefaults(table, value) {
-	const columns = table[Columns];
-	if (!columns) return value;
-	const result = { ...value };
-	const polymorphicConfigs = getTablePolymorphicConfigs(table);
-	const activeGeneratedFields = /* @__PURE__ */ new Set();
-	const generatedFields = /* @__PURE__ */ new Set();
-	for (const config of polymorphicConfigs) {
-		for (const fieldName of config.generatedFieldNames) generatedFields.add(fieldName);
-		const discriminatorValue = result[config.discriminator];
-		if (typeof discriminatorValue !== "string") continue;
-		const activeVariant = config.variants[discriminatorValue];
-		if (!activeVariant) continue;
-		for (const fieldName of activeVariant.fieldNames) activeGeneratedFields.add(fieldName);
-	}
-	for (const [columnName, builder] of Object.entries(columns)) {
-		if (result[columnName] !== void 0) continue;
-		if (generatedFields.has(columnName) && !activeGeneratedFields.has(columnName)) continue;
-		const config = builder.config;
-		if (!config) continue;
-		if (typeof config.defaultFn === "function") {
-			result[columnName] = config.defaultFn();
-			continue;
-		}
-		if (config.hasDefault) {
-			result[columnName] = config.default;
-			continue;
-		}
-		if (typeof config.onUpdateFn === "function") result[columnName] = config.onUpdateFn();
-	}
-	return result;
-}
-async function enforceUniqueIndexes(db, table, candidate, options) {
-	const uniqueIndexes = getUniqueIndexes(table);
-	if (uniqueIndexes.length === 0) return;
-	const tableName = getTableName(table);
-	const changedFields = options?.changedFields;
-	for (const index of uniqueIndexes) {
-		if (changedFields && !index.fields.some((field) => changedFields.has(field))) continue;
-		const entries = index.fields.map((field) => [field, candidate[field]]);
-		if (entries.some(([, value]) => value === void 0 || value === null) && !index.nullsNotDistinct) continue;
-		const existing = await db.query(tableName).withIndex(index.name, (q) => {
-			let builder = q.eq(entries[0][0], entries[0][1]);
-			for (let i = 1; i < entries.length; i++) builder = builder.eq(entries[i][0], entries[i][1]);
-			return builder;
-		}).unique();
-		if (existing !== null && (options?.currentId === void 0 || existing._id !== options.currentId)) throw new Error(`Unique index '${index.name}' violation on '${tableName}'.`);
-	}
-}
-async function enforceForeignKeys(db, table, candidate, options) {
-	const foreignKeys = getForeignKeys(table);
-	if (foreignKeys.length === 0) return;
-	const tableName = getTableName(table);
-	const changedFields = options?.changedFields;
-	for (const foreignKey of foreignKeys) {
-		if (changedFields && !foreignKey.columns.some((field) => changedFields.has(field))) continue;
-		const entries = foreignKey.columns.map((field) => [field, candidate[field]]);
-		if (entries.some(([, value]) => value === void 0 || value === null)) continue;
-		if (foreignKey.foreignColumns.length === 1 && foreignKey.foreignColumns[0] === "_id") {
-			const foreignId = entries[0]?.[1];
-			if (!await db.get(foreignId)) throw new Error(`Foreign key violation on '${tableName}': missing document in '${foreignKey.foreignTableName}'.`);
-			continue;
-		}
-		if (!foreignKey.foreignTable) throw new Error(`Foreign key on '${tableName}' requires indexed foreign columns on '${foreignKey.foreignTableName}'.`);
-		const indexName = findIndexForColumns(getIndexes(foreignKey.foreignTable), foreignKey.foreignColumns);
-		if (!indexName) throw new Error(`Foreign key on '${tableName}' requires index on '${foreignKey.foreignTableName}(${foreignKey.foreignColumns.join(", ")})'.`);
-		if (!await db.query(foreignKey.foreignTableName).withIndex(indexName, (q) => {
-			let builder = q.eq(foreignKey.foreignColumns[0], entries[0][1]);
-			for (let i = 1; i < entries.length; i++) builder = builder.eq(foreignKey.foreignColumns[i], entries[i][1]);
-			return builder;
-		}).first()) throw new Error(`Foreign key violation on '${tableName}': missing document in '${foreignKey.foreignTableName}'.`);
-	}
-}
-function getIndexForForeignKey(foreignKey) {
-	return findIndexForColumns(getIndexes(foreignKey.sourceTable), foreignKey.sourceColumns);
-}
-function foreignKeyIndexError(foreignKey) {
-	return /* @__PURE__ */ new Error(`Foreign key on '${foreignKey.sourceTableName}' requires index on '${foreignKey.sourceTableName}(${foreignKey.sourceColumns.join(", ")})' for cascading actions.`);
-}
-function buildIndexPredicate(q, columns, values) {
-	let builder = q.eq(columns[0], values[0]);
-	for (let i = 1; i < columns.length; i++) builder = builder.eq(columns[i], values[i]);
-	return builder;
-}
-function buildFilterPredicate(q, columns, values) {
-	let expr = q.eq(q.field(columns[0]), values[0]);
-	for (let i = 1; i < columns.length; i++) expr = q.and(expr, q.eq(q.field(columns[i]), values[i]));
-	return expr;
-}
-function ensureNullableColumns(table, columns, context) {
-	for (const columnName of columns) {
-		const config = getColumnConfig(table, columnName);
-		if (!config) throw new Error(`${context}: missing column '${columnName}' in table '${getTableName(table)}'.`);
-		if (config.notNull) throw new Error(`${context}: column '${columnName}' is not nullable in '${getTableName(table)}'.`);
-	}
-}
-function ensureDefaultColumns(table, columns, context) {
-	const defaults = {};
-	for (const columnName of columns) {
-		const config = getColumnConfig(table, columnName);
-		if (!config) throw new Error(`${context}: missing column '${columnName}' in table '${getTableName(table)}'.`);
-		if (!config.hasDefault) throw new Error(`${context}: column '${columnName}' has no default in '${getTableName(table)}'.`);
-		defaults[columnName] = config.default;
-	}
-	return defaults;
-}
-function ensureNonNullValues(table, values, context) {
-	for (const [columnName, value] of Object.entries(values)) if (getColumnConfig(table, columnName)?.notNull && (value === null || value === void 0)) throw new Error(`${context}: column '${columnName}' cannot be null in '${getTableName(table)}'.`);
-}
-async function collectReferencingRows(db, foreignKey, targetValues, indexName, options) {
-	return collectMutationRowsBounded(() => db.query(foreignKey.sourceTableName).withIndex(indexName, (q) => buildIndexPredicate(q, foreignKey.sourceColumns, targetValues)), {
-		operation: options.operation,
-		tableName: foreignKey.sourceTableName,
-		batchSize: options.batchSize,
-		maxRows: options.maxRows
-	});
-}
-async function collectAsyncCascadeRowsBounded(buildQuery, batchSize, maxBytesPerBatch) {
-	const rows = await buildQuery().take(batchSize + 1);
-	const hasMoreRows = rows.length > batchSize;
-	const bounded = takeRowsWithinByteBudget(hasMoreRows ? rows.slice(0, batchSize) : rows, maxBytesPerBatch);
-	return {
-		rows: bounded.rows,
-		needsContinuation: hasMoreRows || bounded.hitLimit
-	};
-}
-async function hasReferencingRow(db, foreignKey, targetValues, indexName) {
-	const query = db.query(foreignKey.sourceTableName);
-	return (indexName ? await query.withIndex(indexName, (q) => buildIndexPredicate(q, foreignKey.sourceColumns, targetValues)).first() : await query.filter((q) => buildFilterPredicate(q, foreignKey.sourceColumns, targetValues)).first()) !== null;
-}
-async function softDeleteRow(db, table, row) {
-	const tableName = getTableName(table);
-	if (!("deletionTime" in getTableColumns$2(table))) throw new Error(`Soft delete requires 'deletionTime' field on '${tableName}'.`);
-	const deletionTime = Date.now();
-	await db.patch(tableName, row._id, { deletionTime });
-	return deletionTime;
-}
-/**
-* Applies one loop-invariant payload to every referencing row. The ids come
-* from a single index scan so they are distinct, and the write set is
-* order-independent — but a table whose writes run through lifecycle hooks
-* keeps the sequential loop: those writes are serialized by the lifecycle write
-* lock anyway, and their hooks would otherwise fire out of write order.
-*/
-async function patchReferencingRows(db, tableName, rows, patch) {
-	if (hasLifecycleHooks(db, tableName)) {
-		for (const row of rows) await db.patch(tableName, row._id, patch);
-		return;
-	}
-	await mapWithConcurrency(rows, DEFAULT_WRITE_FANOUT_CONCURRENCY, async (row) => {
-		await db.patch(tableName, row._id, patch);
-	});
-}
-async function hardDeleteRow(db, tableName, row) {
-	await db.delete(tableName, row._id);
-}
-async function applyIncomingForeignKeyActionsOnDelete(db, table, row, options) {
-	const tableName = getTableName(table);
-	const incoming = options.graph.incomingByTable.get(tableName) ?? [];
-	if (incoming.length === 0) return;
-	for (const foreignKey of incoming) {
-		const action = foreignKey.onDelete ?? "no action";
-		const targetValues = foreignKey.targetColumns.map((column) => row[column]);
-		if (targetValues.some((value) => value === void 0 || value === null)) continue;
-		const indexName = getIndexForForeignKey(foreignKey);
-		if (action === "restrict" || action === "no action") {
-			if (!indexName && !options.allowFullScan) throw foreignKeyIndexError(foreignKey);
-			if (!indexName && options.strict) console.warn(`Foreign key check running without index (allowFullScan: true) on '${foreignKey.sourceTableName}'.`);
-			if (await hasReferencingRow(db, foreignKey, targetValues, indexName)) throw new Error(`Foreign key restrict violation on '${tableName}' from '${foreignKey.sourceTableName}'.`);
-			continue;
-		}
-		if (!indexName) {
-			if (!options.allowFullScan) throw foreignKeyIndexError(foreignKey);
-			if (options.strict) console.warn(`Foreign key cascade check running without index (allowFullScan: true) on '${foreignKey.sourceTableName}'.`);
-			if (await hasReferencingRow(db, foreignKey, targetValues, null)) throw foreignKeyIndexError(foreignKey);
-			continue;
-		}
-		let referencingRows;
-		if (options.executionMode === "async") {
-			const asyncBatchSize = action === "cascade" ? options.batchSize : options.leafBatchSize;
-			const { rows, needsContinuation } = await collectAsyncCascadeRowsBounded(() => db.query(foreignKey.sourceTableName).withIndex(indexName, (q) => buildIndexPredicate(q, foreignKey.sourceColumns, targetValues)), asyncBatchSize, options.maxBytesPerBatch);
-			referencingRows = rows;
-			if (needsContinuation) {
-				if (!options.scheduler || !options.scheduledMutationBatch) throw new Error("Async mutation execution requires orm.db(ctx) configured with scheduling (ormFunctions.scheduledMutationBatch).");
-				consumeScheduleCall(options.scheduleState);
-				await options.scheduler.runAfter(options.delayMs ?? 0, options.scheduledMutationBatch, {
-					workType: "cascade-delete",
-					mode: "async",
-					operation: "delete",
-					table: foreignKey.sourceTableName,
-					foreignIndexName: indexName,
-					foreignSourceColumns: foreignKey.sourceColumns,
-					targetValues: encodeUndefinedDeep(targetValues),
-					foreignAction: action,
-					deleteMode: options.deleteMode,
-					cascadeMode: options.cascadeMode,
-					cursor: null,
-					batchSize: asyncBatchSize,
-					maxBytesPerBatch: options.maxBytesPerBatch,
-					delayMs: options.delayMs ?? 0
-				});
-			}
-		} else referencingRows = await collectReferencingRows(db, foreignKey, targetValues, indexName, {
-			operation: "delete",
-			batchSize: options.batchSize,
-			maxRows: options.maxRows
-		});
-		if (referencingRows.length === 0) continue;
-		if (action === "set null") {
-			ensureNullableColumns(foreignKey.sourceTable, foreignKey.sourceColumns, `Foreign key set null on '${foreignKey.sourceTableName}'`);
-			const nullPatch = {};
-			for (const columnName of foreignKey.sourceColumns) nullPatch[columnName] = null;
-			await patchReferencingRows(db, foreignKey.sourceTableName, referencingRows, nullPatch);
-			continue;
-		}
-		if (action === "set default") {
-			const defaults = ensureDefaultColumns(foreignKey.sourceTable, foreignKey.sourceColumns, `Foreign key set default on '${foreignKey.sourceTableName}'`);
-			await patchReferencingRows(db, foreignKey.sourceTableName, referencingRows, defaults);
-			continue;
-		}
-		if (action === "cascade") for (const referencingRow of referencingRows) {
-			const key = `${foreignKey.sourceTableName}:${referencingRow._id}`;
-			if (options.visited.has(key)) continue;
-			options.visited.add(key);
-			await applyIncomingForeignKeyActionsOnDelete(db, foreignKey.sourceTable, referencingRow, options);
-			if (options.cascadeMode === "soft") await softDeleteRow(db, foreignKey.sourceTable, referencingRow);
-			else await hardDeleteRow(db, foreignKey.sourceTableName, referencingRow);
-		}
-	}
-}
-async function applyIncomingForeignKeyActionsOnUpdate(db, table, oldRow, newRow, options) {
-	const tableName = getTableName(table);
-	const incoming = options.graph.incomingByTable.get(tableName) ?? [];
-	if (incoming.length === 0) return;
-	for (const foreignKey of incoming) {
-		const action = foreignKey.onUpdate ?? "no action";
-		const oldValues = foreignKey.targetColumns.map((column) => oldRow[column]);
-		const newValues = foreignKey.targetColumns.map((column) => newRow[column]);
-		if (!oldValues.some((value, index) => !Object.is(value, newValues[index]))) continue;
-		if (oldValues.some((value) => value === void 0 || value === null)) continue;
-		const indexName = getIndexForForeignKey(foreignKey);
-		if (action === "restrict" || action === "no action") {
-			if (!indexName && !options.allowFullScan) throw foreignKeyIndexError(foreignKey);
-			if (!indexName && options.strict) console.warn(`Foreign key check running without index (allowFullScan: true) on '${foreignKey.sourceTableName}'.`);
-			if (await hasReferencingRow(db, foreignKey, oldValues, indexName)) throw new Error(`Foreign key restrict violation on '${tableName}' from '${foreignKey.sourceTableName}'.`);
-			continue;
-		}
-		if (!indexName) {
-			if (!options.allowFullScan) throw foreignKeyIndexError(foreignKey);
-			if (options.strict) console.warn(`Foreign key cascade check running without index (allowFullScan: true) on '${foreignKey.sourceTableName}'.`);
-			if (await hasReferencingRow(db, foreignKey, oldValues, null)) throw foreignKeyIndexError(foreignKey);
-			continue;
-		}
-		let referencingRows;
-		if (options.executionMode === "async") {
-			const asyncBatchSize = options.leafBatchSize;
-			const { rows, needsContinuation } = await collectAsyncCascadeRowsBounded(() => db.query(foreignKey.sourceTableName).withIndex(indexName, (q) => buildIndexPredicate(q, foreignKey.sourceColumns, oldValues)), asyncBatchSize, options.maxBytesPerBatch);
-			referencingRows = rows;
-			if (needsContinuation) {
-				if (!options.scheduler || !options.scheduledMutationBatch) throw new Error("Async mutation execution requires orm.db(ctx) configured with scheduling (ormFunctions.scheduledMutationBatch).");
-				consumeScheduleCall(options.scheduleState);
-				await options.scheduler.runAfter(options.delayMs ?? 0, options.scheduledMutationBatch, {
-					workType: "cascade-update",
-					mode: "async",
-					operation: "update",
-					table: foreignKey.sourceTableName,
-					foreignIndexName: indexName,
-					foreignSourceColumns: foreignKey.sourceColumns,
-					targetValues: encodeUndefinedDeep(oldValues),
-					newValues: encodeUndefinedDeep(newValues),
-					foreignAction: action,
-					cursor: null,
-					batchSize: asyncBatchSize,
-					maxBytesPerBatch: options.maxBytesPerBatch,
-					delayMs: options.delayMs ?? 0
-				});
-			}
-		} else referencingRows = await collectReferencingRows(db, foreignKey, oldValues, indexName, {
-			operation: "update",
-			batchSize: options.batchSize,
-			maxRows: options.maxRows
-		});
-		if (referencingRows.length === 0) continue;
-		if (action === "set null") {
-			ensureNullableColumns(foreignKey.sourceTable, foreignKey.sourceColumns, `Foreign key set null on '${foreignKey.sourceTableName}'`);
-			const nullPatch = {};
-			for (const columnName of foreignKey.sourceColumns) nullPatch[columnName] = null;
-			await patchReferencingRows(db, foreignKey.sourceTableName, referencingRows, nullPatch);
-			continue;
-		}
-		if (action === "set default") {
-			const defaults = ensureDefaultColumns(foreignKey.sourceTable, foreignKey.sourceColumns, `Foreign key set default on '${foreignKey.sourceTableName}'`);
-			await patchReferencingRows(db, foreignKey.sourceTableName, referencingRows, defaults);
-			continue;
-		}
-		if (action === "cascade") {
-			const patchValues = {};
-			for (let i = 0; i < foreignKey.sourceColumns.length; i++) patchValues[foreignKey.sourceColumns[i]] = newValues[i];
-			ensureNonNullValues(foreignKey.sourceTable, patchValues, `Foreign key cascade update on '${foreignKey.sourceTableName}'`);
-			await patchReferencingRows(db, foreignKey.sourceTableName, referencingRows, patchValues);
-		}
-	}
-}
-function getSelectionColumnName(value) {
-	if (value && typeof value === "object") {
-		if ("columnName" in value) return value.columnName;
-		if ("config" in value && value.config?.name) return value.config.name;
-	}
-	throw new Error("Returning selection must reference a column");
-}
-function splitReturningSelection(fields) {
-	const columnSelection = {};
-	let countSelection;
-	for (const [key, value] of Object.entries(fields)) {
-		if (key !== "_count") {
-			getSelectionColumnName(value);
-			columnSelection[key] = value;
-			continue;
-		}
-		if (value === void 0) continue;
-		if (!isPlainObject$1(value)) throw new Error("returning({ _count }) requires an object.");
-		const nextCountSelection = {};
-		for (const [relationName, relationSelection] of Object.entries(value)) {
-			if (relationSelection === void 0 || relationSelection === false) continue;
-			if (relationSelection === true) {
-				nextCountSelection[relationName] = true;
-				continue;
-			}
-			if (!isPlainObject$1(relationSelection)) throw new Error(`returning({ _count.${relationName} }) must be true or { where }`);
-			if ("select" in relationSelection) throw new Error(`returning({ _count.${relationName}.select }) is removed. Use returning({ _count: { ${relationName}: true } })`);
-			for (const [optionKey, optionValue] of Object.entries(relationSelection)) if (optionKey !== "where" && optionValue !== void 0) throw new Error(`returning({ _count.${relationName} }) does not support '${optionKey}'`);
-			if (typeof relationSelection.where === "function") throw new Error(`returning({ _count.${relationName}.where }) callback is unsupported in v1`);
-			nextCountSelection[relationName] = { where: relationSelection.where };
-		}
-		countSelection = nextCountSelection;
-	}
-	return {
-		columnSelection: Object.keys(columnSelection).length > 0 ? columnSelection : void 0,
-		countSelection
-	};
-}
-const matchLike = matchLikePattern;
-function evaluateFilter(row, filter) {
-	if (filter.type === "binary") {
-		const [field, value] = filter.operands;
-		if (!isFieldReference(field)) throw new Error("Binary expression must have FieldReference as first operand");
-		const fieldValue = row[field.fieldName];
-		switch (filter.operator) {
-			case "like": {
-				const pattern = value;
-				if (typeof fieldValue !== "string") return false;
-				return matchLike(fieldValue, pattern, false);
-			}
-			case "ilike": {
-				const pattern = value;
-				if (typeof fieldValue !== "string") return false;
-				return matchLike(fieldValue, pattern, true);
-			}
-			case "notLike": {
-				const pattern = value;
-				if (typeof fieldValue !== "string") return false;
-				return !matchLike(fieldValue, pattern, false);
-			}
-			case "notIlike": {
-				const pattern = value;
-				if (typeof fieldValue !== "string") return false;
-				return !matchLike(fieldValue, pattern, true);
-			}
-			case "startsWith":
-				if (typeof fieldValue !== "string") return false;
-				return fieldValue.startsWith(value);
-			case "endsWith":
-				if (typeof fieldValue !== "string") return false;
-				return fieldValue.endsWith(value);
-			case "contains":
-				if (typeof fieldValue !== "string") return false;
-				return fieldValue.includes(value);
-			case "eq": return filterValuesEqual(fieldValue, value);
-			case "ne": return !filterValuesEqual(fieldValue, value);
-			case "gt": return fieldValue > value;
-			case "gte": return fieldValue >= value;
-			case "lt": return fieldValue < value;
-			case "lte": return fieldValue <= value;
-			case "inArray": return filterValueInList(fieldValue, value);
-			case "notInArray": return !filterValueInList(fieldValue, value);
-			case "arrayContains":
-				if (!Array.isArray(fieldValue)) return false;
-				return value.every((item) => fieldValue.includes(item));
-			case "arrayContained": {
-				if (!Array.isArray(fieldValue)) return false;
-				const arr = value;
-				return fieldValue.every((item) => arr.includes(item));
-			}
-			case "arrayOverlaps": {
-				if (!Array.isArray(fieldValue)) return false;
-				const arr = value;
-				return fieldValue.some((item) => arr.includes(item));
-			}
-			default: throw new Error(`Unsupported post-fetch operator: ${filter.operator}`);
-		}
-	}
-	if (filter.type === "unary") {
-		const [operand] = filter.operands;
-		if (isFieldReference(operand)) {
-			const fieldValue = row[operand.fieldName];
-			switch (filter.operator) {
-				case "isNull": return fieldValue === null || fieldValue === void 0;
-				case "isNotNull": return fieldValue !== null && fieldValue !== void 0;
-				default: throw new Error(`Unsupported unary operator: ${filter.operator}`);
-			}
-		}
-		if (filter.operator === "not") return !evaluateFilter(row, operand);
-		throw new Error("Unary expression must have FieldReference or FilterExpression as operand");
-	}
-	if (filter.type === "logical") {
-		if (filter.operator === "and") return filter.operands.every((f) => evaluateFilter(row, f));
-		if (filter.operator === "or") return filter.operands.some((f) => evaluateFilter(row, f));
-	}
-	throw new Error(`Unsupported filter type for post-fetch: ${filter.type}`);
-}
-function triNot(value) {
-	return value === "unknown" ? "unknown" : !value;
-}
-function triAnd(values) {
-	if (values.some((value) => value === false)) return false;
-	if (values.every((value) => value === true)) return true;
-	return "unknown";
-}
-function triOr(values) {
-	if (values.some((value) => value === true)) return true;
-	if (values.every((value) => value === false)) return false;
-	return "unknown";
-}
-function evaluateCheckConstraintTriState(row, filter) {
-	if (filter.type === "binary") {
-		const [field, value] = filter.operands;
-		if (!isFieldReference(field)) throw new Error("Binary expression must have FieldReference as first operand");
-		const fieldValue = row[field.fieldName];
-		const compareValue = isFieldReference(value) ? row[value.fieldName] : value;
-		const nullish = (entry) => entry === null || entry === void 0;
-		if (nullish(fieldValue) || nullish(compareValue)) return "unknown";
-		switch (filter.operator) {
-			case "like":
-				if (typeof fieldValue !== "string" || typeof compareValue !== "string") return false;
-				return matchLike(fieldValue, compareValue, false);
-			case "ilike":
-				if (typeof fieldValue !== "string" || typeof compareValue !== "string") return false;
-				return matchLike(fieldValue, compareValue, true);
-			case "notLike":
-				if (typeof fieldValue !== "string" || typeof compareValue !== "string") return false;
-				return !matchLike(fieldValue, compareValue, false);
-			case "notIlike":
-				if (typeof fieldValue !== "string" || typeof compareValue !== "string") return false;
-				return !matchLike(fieldValue, compareValue, true);
-			case "startsWith":
-				if (typeof fieldValue !== "string" || typeof compareValue !== "string") return false;
-				return fieldValue.startsWith(compareValue);
-			case "endsWith":
-				if (typeof fieldValue !== "string" || typeof compareValue !== "string") return false;
-				return fieldValue.endsWith(compareValue);
-			case "contains":
-				if (typeof fieldValue !== "string" || typeof compareValue !== "string") return false;
-				return fieldValue.includes(compareValue);
-			case "eq": return fieldValue === compareValue;
-			case "ne": return fieldValue !== compareValue;
-			case "gt": return fieldValue > compareValue;
-			case "gte": return fieldValue >= compareValue;
-			case "lt": return fieldValue < compareValue;
-			case "lte": return fieldValue <= compareValue;
-			case "inArray": {
-				const arr = compareValue;
-				if (!Array.isArray(arr)) return false;
-				if (arr.includes(fieldValue)) return true;
-				return arr.some(nullish) ? "unknown" : false;
-			}
-			case "notInArray": {
-				const arr = compareValue;
-				if (!Array.isArray(arr)) return false;
-				if (arr.includes(fieldValue)) return false;
-				return arr.some(nullish) ? "unknown" : true;
-			}
-			case "arrayContains": {
-				if (!Array.isArray(fieldValue)) return false;
-				const arr = compareValue;
-				if (!Array.isArray(arr)) return false;
-				return arr.every((item) => fieldValue.includes(item));
-			}
-			case "arrayContained": {
-				if (!Array.isArray(fieldValue)) return false;
-				const arr = compareValue;
-				if (!Array.isArray(arr)) return false;
-				return fieldValue.every((item) => arr.includes(item));
-			}
-			case "arrayOverlaps": {
-				if (!Array.isArray(fieldValue)) return false;
-				const arr = compareValue;
-				if (!Array.isArray(arr)) return false;
-				return fieldValue.some((item) => arr.includes(item));
-			}
-			default: throw new Error(`Unsupported operator: ${filter.operator}`);
-		}
-	}
-	if (filter.type === "unary") {
-		const [operand] = filter.operands;
-		if (isFieldReference(operand)) {
-			const fieldValue = row[operand.fieldName];
-			switch (filter.operator) {
-				case "isNull": return fieldValue === null || fieldValue === void 0;
-				case "isNotNull": return fieldValue !== null && fieldValue !== void 0;
-				default: throw new Error(`Unsupported unary operator: ${filter.operator}`);
-			}
-		}
-		if (filter.operator === "not") return triNot(evaluateCheckConstraintTriState(row, operand));
-		throw new Error("Unary expression must have FieldReference or FilterExpression as operand");
-	}
-	if (filter.type === "logical") {
-		if (filter.operator === "and") return triAnd(filter.operands.map((operand) => evaluateCheckConstraintTriState(row, operand)));
-		if (filter.operator === "or") return triOr(filter.operands.map((operand) => evaluateCheckConstraintTriState(row, operand)));
-	}
-	throw new Error(`Unsupported filter type for check: ${filter.type}`);
-}
-function enforceCheckConstraints(table, candidate) {
-	const checks = getChecks(table);
-	if (checks.length === 0) return;
-	const tableName = getTableName(table);
-	for (const check of checks) if (evaluateCheckConstraintTriState(candidate, check.expression) === false) throw new Error(`Check constraint '${check.name}' violation on '${tableName}'.`);
-}
-function toConvexFilter(expression) {
-	const visitor = {
-		visitBinary: (expr) => {
-			const [field, value] = expr.operands;
-			if (!isFieldReference(field)) throw new Error("Binary expression must have FieldReference as first operand");
-			const fieldName = field.fieldName;
-			switch (expr.operator) {
-				case "eq": return (q) => q.eq(q.field(fieldName), value);
-				case "ne": return (q) => q.neq(q.field(fieldName), value);
-				case "gt": return (q) => q.gt(q.field(fieldName), value);
-				case "gte": return (q) => q.gte(q.field(fieldName), value);
-				case "lt": return (q) => q.lt(q.field(fieldName), value);
-				case "lte": return (q) => q.lte(q.field(fieldName), value);
-				case "inArray": {
-					const values = value;
-					return (q) => {
-						if (values.length === 0) return q.eq(q.field("_id"), "__better_convex_never__");
-						return values.map((v) => q.eq(q.field(fieldName), v)).reduce((acc, cond) => q.or(acc, cond));
-					};
-				}
-				case "notInArray": {
-					const values = value;
-					return (q) => {
-						return values.map((v) => q.neq(q.field(fieldName), v)).reduce((acc, cond) => q.and(acc, cond));
-					};
-				}
-				case "like":
-				case "ilike":
-				case "notLike":
-				case "notIlike":
-				case "startsWith":
-				case "endsWith":
-				case "contains":
-				case "arrayContains":
-				case "arrayContained":
-				case "arrayOverlaps": return () => true;
-				default: throw new Error(`Unsupported binary operator: ${expr.operator}`);
-			}
-		},
-		visitLogical: (expr) => {
-			const operandFns = expr.operands.map((op) => op.accept(visitor));
-			if (expr.operator === "and") return (q) => {
-				let result = operandFns[0](q);
-				for (let i = 1; i < operandFns.length; i++) result = q.and(result, operandFns[i](q));
-				return result;
-			};
-			if (expr.operator === "or") return (q) => {
-				let result = operandFns[0](q);
-				for (let i = 1; i < operandFns.length; i++) result = q.or(result, operandFns[i](q));
-				return result;
-			};
-			throw new Error(`Unsupported logical operator: ${expr.operator}`);
-		},
-		visitUnary: (expr) => {
-			const operand = expr.operands[0];
-			if (expr.operator === "not") {
-				const operandFn = operand.accept(visitor);
-				return (q) => q.not(operandFn(q));
-			}
-			if (expr.operator === "isNull") {
-				if (!isFieldReference(operand)) throw new Error("isNull must operate on a field reference");
-				const fieldName = operand.fieldName;
-				return (q) => q.eq(q.field(fieldName), null);
-			}
-			if (expr.operator === "isNotNull") {
-				if (!isFieldReference(operand)) throw new Error("isNotNull must operate on a field reference");
-				const fieldName = operand.fieldName;
-				return (q) => q.neq(q.field(fieldName), null);
-			}
-			throw new Error(`Unsupported unary operator: ${expr.operator}`);
-		}
-	};
-	return expression.accept(visitor);
-}
-
-//#endregion
-//#region src/orm/extensions.ts
-function defineChainMethod$1(target, key, value) {
-	Object.defineProperty(target, key, {
-		value,
-		enumerable: false,
-		configurable: true
-	});
-}
-function createSchemaExtensionChain(state, capabilities) {
-	const extension = {
-		key: state.key,
-		tables: state.tables
-	};
-	Object.defineProperty(extension, OrmSchemaExtensionRelations, {
-		value: state.relations,
-		enumerable: false,
-		configurable: true
-	});
-	Object.defineProperty(extension, OrmSchemaExtensionTriggers, {
-		value: state.triggers,
-		enumerable: false,
-		configurable: true
-	});
-	if (capabilities.canRelations) defineChainMethod$1(extension, "relations", (relations) => createSchemaExtensionChain({
-		...state,
-		relations
-	}, {
-		canRelations: false,
-		canTriggers: true
-	}));
-	if (capabilities.canTriggers) defineChainMethod$1(extension, "triggers", (triggers) => createSchemaExtensionChain({
-		...state,
-		triggers
-	}, {
-		canRelations: false,
-		canTriggers: false
-	}));
-	return extension;
-}
-function defineSchemaExtension(key, tables) {
-	return createSchemaExtensionChain({
-		key,
-		tables,
-		relations: void 0,
-		triggers: void 0
-	}, {
-		canRelations: true,
-		canTriggers: true
-	});
-}
-
-//#endregion
-//#region src/orm/aggregate-index/schema.ts
-const AGGREGATE_BUCKET_TABLE = "aggregate_bucket";
-const AGGREGATE_MEMBER_TABLE = "aggregate_member";
-const AGGREGATE_EXTREMA_TABLE = "aggregate_extrema";
-const AGGREGATE_RANK_TREE_TABLE = "aggregate_rank_tree";
-const AGGREGATE_RANK_NODE_TABLE = "aggregate_rank_node";
-const AGGREGATE_STATE_TABLE = "aggregate_state";
-const countBucketTable = convexTable(AGGREGATE_BUCKET_TABLE, {
-	tableKey: text().notNull(),
-	indexName: text().notNull(),
-	keyHash: text().notNull(),
-	keyParts: arrayOf(json()).notNull(),
-	count: integer().notNull(),
-	sumValues: objectOf(integer().notNull()).notNull(),
-	nonNullCountValues: objectOf(integer().notNull()).notNull(),
-	updatedAt: integer().notNull()
-}, (t) => [index("by_table_index_hash").on(t.tableKey, t.indexName, t.keyHash), index("by_table_index").on(t.tableKey, t.indexName)]);
-const countMemberTable = convexTable(AGGREGATE_MEMBER_TABLE, {
-	kind: text().notNull(),
-	tableKey: text().notNull(),
-	indexName: text().notNull(),
-	docId: text().notNull(),
-	keyHash: text().notNull(),
-	keyParts: arrayOf(json()).notNull(),
-	sumValues: objectOf(integer().notNull()).notNull(),
-	nonNullCountValues: objectOf(integer().notNull()).notNull(),
-	extremaValues: objectOf(json()).notNull(),
-	rankNamespace: json(),
-	rankKey: json(),
-	rankSumValue: integer(),
-	updatedAt: integer().notNull()
-}, (t) => [index("by_kind_table_index_doc").on(t.kind, t.tableKey, t.indexName, t.docId), index("by_kind_table_index").on(t.kind, t.tableKey, t.indexName)]);
-const countExtremaTable = convexTable(AGGREGATE_EXTREMA_TABLE, {
-	tableKey: text().notNull(),
-	indexName: text().notNull(),
-	keyHash: text().notNull(),
-	fieldName: text().notNull(),
-	valueHash: text().notNull(),
-	value: json().notNull(),
-	sortKey: text().notNull(),
-	count: integer().notNull(),
-	updatedAt: integer().notNull()
-}, (t) => [
-	index("by_table_index").on(t.tableKey, t.indexName),
-	index("by_table_index_hash_field_value").on(t.tableKey, t.indexName, t.keyHash, t.fieldName, t.valueHash),
-	index("by_table_index_hash_field_sort").on(t.tableKey, t.indexName, t.keyHash, t.fieldName, t.sortKey)
-]);
-const countStateTable = convexTable(AGGREGATE_STATE_TABLE, {
-	kind: text().notNull(),
-	tableKey: text().notNull(),
-	indexName: text().notNull(),
-	keyDefinitionHash: text().notNull(),
-	metricDefinitionHash: text().notNull(),
-	status: text().notNull(),
-	cursor: text(),
-	processed: integer().notNull(),
-	startedAt: integer().notNull(),
-	updatedAt: integer().notNull(),
-	completedAt: integer(),
-	lastError: text()
-}, (t) => [
-	index("by_kind_table_index").on(t.kind, t.tableKey, t.indexName),
-	index("by_kind_status").on(t.kind, t.status),
-	index("by_table_status").on(t.tableKey, t.status)
-]);
-const rankTreeTable = convexTable(AGGREGATE_RANK_TREE_TABLE, {
-	aggregateName: text().notNull(),
-	maxNodeSize: integer().notNull(),
-	namespace: json(),
-	root: id(AGGREGATE_RANK_NODE_TABLE).notNull()
-}, (tree) => [index("by_namespace").on(tree.namespace), index("by_aggregate_name").on(tree.aggregateName)]);
-const rankNodeTable = convexTable(AGGREGATE_RANK_NODE_TABLE, {
-	aggregate: objectOf({
-		count: integer().notNull(),
-		sum: integer().notNull()
-	}),
-	items: arrayOf(objectOf({
-		k: json(),
-		v: json(),
-		s: integer().notNull()
-	})).notNull(),
-	subtrees: arrayOf(text().notNull()).notNull()
-});
-const aggregateStorageTables = {
-	[AGGREGATE_BUCKET_TABLE]: countBucketTable,
-	[AGGREGATE_MEMBER_TABLE]: countMemberTable,
-	[AGGREGATE_EXTREMA_TABLE]: countExtremaTable,
-	[AGGREGATE_RANK_TREE_TABLE]: rankTreeTable,
-	[AGGREGATE_RANK_NODE_TABLE]: rankNodeTable,
-	[AGGREGATE_STATE_TABLE]: countStateTable
-};
-function aggregateExtension() {
-	return defineSchemaExtension("aggregate", aggregateStorageTables);
-}
-
-//#endregion
-//#region src/orm/aggregate-index/runtime.ts
-const UNDEFINED_SENTINEL = "__kitcnUndefined";
-const FLOAT64_SIGN_BIT = 1n << 63n;
-const FLOAT64_MASK = (1n << 64n) - 1n;
-const DEFAULT_AGGREGATE_CARTESIAN_MAX_KEYS$1 = 4096;
-const DEFAULT_AGGREGATE_WORK_BUDGET$1 = 16384;
-const RANGE_PREFIX_WORK_UNIT_BASE = 2;
-const AGGREGATE_BUCKET_READ_CONCURRENCY = 25;
-const PUBLIC_ID_FIELD$1 = "id";
-const INTERNAL_ID_FIELD$1 = "_id";
-const AGGREGATE_STATE_KIND_METRIC = "metric";
-const AGGREGATE_STATE_KIND_RANK = "rank";
-const COUNT_STATUS_BUILDING = "BUILDING";
-const COUNT_STATUS_READY = "READY";
-/** Stored state is being drained before a rebuild, across several mutations. */
-const COUNT_STATUS_CLEARING = "CLEARING";
-const COUNT_ERROR = {
-	FILTER_UNSUPPORTED: "COUNT_FILTER_UNSUPPORTED",
-	NOT_INDEXED: "COUNT_NOT_INDEXED",
-	INDEX_BUILDING: "COUNT_INDEX_BUILDING",
-	RLS_UNSUPPORTED: "COUNT_RLS_UNSUPPORTED"
-};
-const AGGREGATE_ERROR = {
-	ARGS_UNSUPPORTED: "AGGREGATE_ARGS_UNSUPPORTED",
-	FILTER_UNSUPPORTED: "AGGREGATE_FILTER_UNSUPPORTED",
-	NOT_INDEXED: "AGGREGATE_NOT_INDEXED",
-	INDEX_BUILDING: "AGGREGATE_INDEX_BUILDING",
-	RLS_UNSUPPORTED: "AGGREGATE_RLS_UNSUPPORTED"
-};
-const RANGE_WORK_STATE = Symbol("aggregateRangeWorkState");
-const isPlainObject = (value) => !!value && typeof value === "object" && !Array.isArray(value);
-const normalizeUndefined = (value) => {
-	if (Array.isArray(value)) return value.map((entry) => normalizeUndefined(entry));
-	if (isPlainObject(value)) return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, normalizeUndefined(entry)]));
-	if (value === void 0) return { [UNDEFINED_SENTINEL]: true };
-	return value;
-};
-const serializeStable = (value) => JSON.stringify(normalizeUndefined(value));
-const toConstraintSet = (values) => {
-	const set = /* @__PURE__ */ new Map();
-	for (const value of values) set.set(serializeStable(value), value);
-	return set;
-};
-const intersectConstraintSets = (left, right) => {
-	const result = /* @__PURE__ */ new Map();
-	for (const [key, value] of left.entries()) if (right.has(key)) result.set(key, value);
-	return result;
-};
-const getColumnNames = (tableConfig) => {
-	const names = new Set(Object.keys(tableConfig.table[Columns] ?? {}));
-	names.add(INTERNAL_ID_FIELD$1);
-	if (usesSystemCreatedAtAlias(tableConfig.table)) names.add(INTERNAL_CREATION_TIME_FIELD);
-	return names;
-};
-const getRelationNames = (tableConfig) => new Set(Object.keys(tableConfig.relations ?? {}));
-const normalizeFilterFieldName = (tableConfig, fieldName) => {
-	if (fieldName === PUBLIC_ID_FIELD$1) return INTERNAL_ID_FIELD$1;
-	if (fieldName === PUBLIC_CREATED_AT_FIELD && usesSystemCreatedAtAlias(tableConfig.table)) return INTERNAL_CREATION_TIME_FIELD;
-	return fieldName;
-};
-const createError = (code, message) => /* @__PURE__ */ new Error(`${code}: ${message}`);
-const createFilterError = (codes, methodName, message) => createError(codes.FILTER_UNSUPPORTED, `${methodName} ${message}`);
-const isRangeComparableValue = (value) => {
-	if (typeof value === "number") return Number.isFinite(value);
-	return typeof value === "string" || typeof value === "boolean";
-};
-const withFieldConstraint = (target, fieldName) => {
-	const existing = target.get(fieldName);
-	if (existing) return existing;
-	const next = {};
-	target.set(fieldName, next);
-	return next;
-};
-const normalizeAggregateComparableValue = (tableConfig, fieldName, value) => {
-	if (fieldName === INTERNAL_CREATION_TIME_FIELD) {
-		if (value instanceof Date) return value.getTime();
-		if (Array.isArray(value)) return value.map((entry) => entry instanceof Date ? entry.getTime() : entry);
-		return value;
-	}
-	return normalizeTemporalComparableValue(tableConfig.table, fieldName, value);
-};
-const pushConstraint = (target, fieldName, values) => {
-	const incoming = toConstraintSet(values);
-	const existing = withFieldConstraint(target, fieldName);
-	if (!existing.values) {
-		existing.values = incoming;
-		return;
-	}
-	existing.values = intersectConstraintSets(existing.values, incoming);
-};
-const pushRangeComparison = (target, fieldName, comparison) => {
-	const existing = withFieldConstraint(target, fieldName);
-	existing.rangeComparisons ??= [];
-	existing.rangeComparisons.push(comparison);
-};
-const matchesRangeComparisons = (value, comparisons) => {
-	if (!isRangeComparableValue(value)) return false;
-	for (const comparison of comparisons) {
-		if (!isRangeComparableValue(comparison.value)) return false;
-		const compared = compareSortableValues(value, comparison.value);
-		if (comparison.operator === "gt" && !(compared > 0)) return false;
-		if (comparison.operator === "gte" && !(compared >= 0)) return false;
-		if (comparison.operator === "lt" && !(compared < 0)) return false;
-		if (comparison.operator === "lte" && !(compared <= 0)) return false;
-	}
-	return true;
-};
-const normalizeConstraints = (constraints, codes, methodName) => {
-	for (const [fieldName, constraint] of constraints.entries()) {
-		if (constraint.rangeComparisons?.length) {
-			for (const comparison of constraint.rangeComparisons) if (!isRangeComparableValue(comparison.value)) throw createFilterError(codes, methodName, `range operators on '${fieldName}' only support finite numbers, strings, and booleans.`);
-		}
-		if (constraint.values && constraint.rangeComparisons?.length) {
-			const filtered = /* @__PURE__ */ new Map();
-			for (const [stableKey, candidate] of constraint.values.entries()) if (matchesRangeComparisons(candidate, constraint.rangeComparisons)) filtered.set(stableKey, candidate);
-			constraint.values = filtered;
-			constraint.rangeComparisons = void 0;
-		}
-		if ((!constraint.values || constraint.values.size === 0) && (!constraint.rangeComparisons || constraint.rangeComparisons.length === 0)) {
-			if (constraint.values && constraint.values.size === 0) continue;
-			constraints.delete(fieldName);
-		}
-	}
-};
-const parseFieldFilter = (tableConfig, fieldName, value, target, codes, methodName) => {
-	if (value === null || typeof value !== "object" || Array.isArray(value)) {
-		pushConstraint(target, fieldName, [normalizeAggregateComparableValue(tableConfig, fieldName, value)]);
-		return;
-	}
-	const filter = value;
-	if (Object.hasOwn(filter, "OR") || Object.hasOwn(filter, "NOT")) throw createFilterError(codes, methodName, `does not support OR/NOT for field '${fieldName}'.`);
-	if (Object.hasOwn(filter, "AND")) {
-		const andEntries = filter.AND;
-		if (!Array.isArray(andEntries)) throw createFilterError(codes, methodName, `field-level AND for '${fieldName}' must be an array.`);
-		for (const entry of andEntries) parseFieldFilter(tableConfig, fieldName, entry, target, codes, methodName);
-	}
-	let hasRecognizedOperator = false;
-	if (Object.hasOwn(filter, "eq")) {
-		hasRecognizedOperator = true;
-		pushConstraint(target, fieldName, [normalizeAggregateComparableValue(tableConfig, fieldName, filter.eq)]);
-	}
-	if (Object.hasOwn(filter, "in")) {
-		hasRecognizedOperator = true;
-		const inValues = filter.in;
-		if (!Array.isArray(inValues)) throw createFilterError(codes, methodName, `field '${fieldName}'.in must be an array.`);
-		pushConstraint(target, fieldName, normalizeAggregateComparableValue(tableConfig, fieldName, inValues));
-	}
-	if (Object.hasOwn(filter, "isNull")) {
-		hasRecognizedOperator = true;
-		if (filter.isNull !== true) throw createFilterError(codes, methodName, `field '${fieldName}'.isNull only supports true.`);
-		pushConstraint(target, fieldName, [null]);
-	}
-	for (const operator of [
-		"gt",
-		"gte",
-		"lt",
-		"lte"
-	]) {
-		if (!Object.hasOwn(filter, operator)) continue;
-		const boundValue = filter[operator];
-		if (boundValue === void 0) continue;
-		hasRecognizedOperator = true;
-		if (boundValue === null || Array.isArray(boundValue) || isPlainObject(boundValue)) throw createFilterError(codes, methodName, `field '${fieldName}'.${operator} requires a scalar bound.`);
-		pushRangeComparison(target, fieldName, {
-			operator,
-			value: normalizeAggregateComparableValue(tableConfig, fieldName, boundValue)
-		});
-	}
-	const unsupportedOperators = Object.keys(filter).filter((operator) => ![
-		"eq",
-		"in",
-		"isNull",
-		"gt",
-		"gte",
-		"lt",
-		"lte",
-		"AND"
-	].includes(operator) && filter[operator] !== void 0);
-	if (unsupportedOperators.length > 0) throw createFilterError(codes, methodName, `does not support operators [${unsupportedOperators.join(", ")}] on '${fieldName}'.`);
-	if (!hasRecognizedOperator && !Object.hasOwn(filter, "AND")) throw createFilterError(codes, methodName, `filter for '${fieldName}' is not supported.`);
-};
-const constraintValuesEqual = (left, right) => {
-	if (!left && !right) return true;
-	if (!left || !right) return false;
-	if (left.size !== right.size) return false;
-	for (const key of left.keys()) if (!right.has(key)) return false;
-	return true;
-};
-const constraintValuesToFilter = (values) => {
-	if (values.size === 1) return values.values().next().value;
-	return { in: [...values.values()] };
-};
-const parseFiniteOrBranch = (options) => {
-	const { branch, tableConfig, codes, methodName } = options;
-	if (Object.hasOwn(branch, "AND") || Object.hasOwn(branch, "OR") || Object.hasOwn(branch, "NOT") || Object.hasOwn(branch, "RAW")) return null;
-	const columnNames = getColumnNames(tableConfig);
-	const relationNames = getRelationNames(tableConfig);
-	const constraints = /* @__PURE__ */ new Map();
-	for (const [key, value] of Object.entries(branch)) {
-		const normalizedKey = normalizeFilterFieldName(tableConfig, key);
-		if (!columnNames.has(normalizedKey)) {
-			if (relationNames.has(key)) throw createFilterError(codes, methodName, `does not support relation filters ('${key}') in v1.`);
-			throw createFilterError(codes, methodName, `filter field '${key}' is not recognized.`);
-		}
-		parseFieldFilter(tableConfig, normalizedKey, value, constraints, codes, methodName);
-	}
-	normalizeConstraints(constraints, codes, methodName);
-	const result = /* @__PURE__ */ new Map();
-	for (const [field, constraint] of constraints.entries()) {
-		if (constraint.rangeComparisons?.length) return null;
-		if (!constraint.values) continue;
-		result.set(field, new Map(constraint.values.entries()));
-	}
-	return result;
-};
-const collapseSafeOrBranches = (options) => {
-	const { branches, tableConfig, codes, methodName } = options;
-	if (branches.length === 0) return null;
-	const branchConstraints = branches.map((branch) => parseFiniteOrBranch({
-		branch,
-		tableConfig,
-		codes,
-		methodName
-	})).filter((entry) => entry !== null);
-	if (branchConstraints.length !== branches.length || branchConstraints.length === 0) return null;
-	const fields = /* @__PURE__ */ new Set();
-	for (const branch of branchConstraints) for (const field of branch.keys()) fields.add(field);
-	if (fields.size === 0) return null;
-	const varyingFields = [];
-	const first = branchConstraints[0];
-	for (const field of fields) {
-		const firstValues = first.get(field);
-		if (branchConstraints.some((branch) => !constraintValuesEqual(firstValues, branch.get(field)))) varyingFields.push(field);
-	}
-	if (varyingFields.length === 0) {
-		const collapsed = {};
-		for (const [field, values] of first.entries()) collapsed[field] = constraintValuesToFilter(values);
-		return collapsed;
-	}
-	if (varyingFields.length !== 1) return null;
-	const varyingField = varyingFields[0];
-	const unionValues = /* @__PURE__ */ new Map();
-	for (const branch of branchConstraints) {
-		const values = branch.get(varyingField);
-		if (!values || values.size === 0) return null;
-		for (const [key, value] of values.entries()) unionValues.set(key, value);
-	}
-	const collapsed = { [varyingField]: constraintValuesToFilter(unionValues) };
-	for (const [field, values] of first.entries()) {
-		if (field === varyingField) continue;
-		collapsed[field] = constraintValuesToFilter(values);
-	}
-	return collapsed;
-};
-const rewriteSafeOrWhere = (options) => {
-	const { where, tableConfig, codes, methodName } = options;
-	if (Object.hasOwn(where, "NOT")) throw createFilterError(codes, methodName, "NOT is not supported in no-scan aggregate/count filters.");
-	const normalized = {};
-	for (const [key, value] of Object.entries(where)) {
-		if (key === "AND") {
-			if (value === void 0) continue;
-			if (!Array.isArray(value)) throw createFilterError(codes, methodName, "AND must be an array of filter objects.");
-			normalized.AND = value.map((entry) => {
-				if (!isPlainObject(entry)) throw createFilterError(codes, methodName, "AND entries must be objects.");
-				return rewriteSafeOrWhere({
-					where: entry,
-					tableConfig,
-					codes,
-					methodName
-				});
-			});
-			continue;
-		}
-		if (key === "OR") continue;
-		normalized[key] = value;
-	}
-	if (!Object.hasOwn(where, "OR")) return normalized;
-	const branches = where.OR;
-	if (!Array.isArray(branches) || branches.length === 0) throw createFilterError(codes, methodName, "OR must be a non-empty array of filter objects.");
-	const collapsedOr = collapseSafeOrBranches({
-		branches: branches.map((entry) => {
-			if (!isPlainObject(entry)) throw createFilterError(codes, methodName, "OR entries must be objects.");
-			return rewriteSafeOrWhere({
-				where: entry,
-				tableConfig,
-				codes,
-				methodName
-			});
-		}),
-		tableConfig,
-		codes,
-		methodName
-	});
-	if (!collapsedOr) throw createFilterError(codes, methodName, "OR rewrite only supports finite index-plannable branches that differ on one scalar eq/in/isNull field.");
-	if (Object.keys(normalized).length === 0) return collapsedOr;
-	return { AND: [normalized, collapsedOr] };
-};
-const parseWhereObject = (where, tableConfig, target, codes, methodName) => {
-	if (Object.hasOwn(where, "OR") || Object.hasOwn(where, "NOT")) throw createFilterError(codes, methodName, "only supports conjunctions (object fields + AND).");
-	if (Object.hasOwn(where, "RAW")) throw createFilterError(codes, methodName, "does not support RAW filters.");
-	if (Object.hasOwn(where, "AND")) {
-		const andEntries = where.AND;
-		if (!Array.isArray(andEntries)) throw createFilterError(codes, methodName, "AND must be an array of filter objects.");
-		for (const entry of andEntries) {
-			if (!isPlainObject(entry)) throw createFilterError(codes, methodName, "AND entries must be objects.");
-			parseWhereObject(entry, tableConfig, target, codes, methodName);
-		}
-	}
-	const columnNames = getColumnNames(tableConfig);
-	const relationNames = getRelationNames(tableConfig);
-	for (const [key, value] of Object.entries(where)) {
-		if (key === "AND") continue;
-		const normalizedKey = normalizeFilterFieldName(tableConfig, key);
-		if (columnNames.has(normalizedKey)) {
-			parseFieldFilter(tableConfig, normalizedKey, value, target, codes, methodName);
-			continue;
-		}
-		if (relationNames.has(key)) throw createFilterError(codes, methodName, `does not support relation filters ('${key}') in v1.`);
-		throw createFilterError(codes, methodName, `filter field '${key}' is not recognized.`);
-	}
-};
-const constraintsToValueRecord = (constraints) => {
-	const record = {};
-	for (const [field, constraint] of constraints.entries()) {
-		if (!constraint.values) continue;
-		record[field] = [...constraint.values.values()];
-	}
-	return record;
-};
-const getAggregateIndexDefinitions = (tableConfig) => {
-	const aggregateIndexes = tableConfig.table.getAggregateIndexes?.();
-	if (!Array.isArray(aggregateIndexes)) return [];
-	return aggregateIndexes.map((entry) => ({
-		name: entry.name,
-		fields: entry.fields ?? [],
-		countFields: entry.countFields ?? [],
-		sumFields: entry.sumFields ?? [],
-		avgFields: entry.avgFields ?? [],
-		minFields: entry.minFields ?? [],
-		maxFields: entry.maxFields ?? []
-	}));
-};
-const supportsMetric = (index, metric) => {
-	if (metric.kind === "count") return true;
-	if (metric.kind === "countField") return index.countFields.includes(metric.field);
-	if (metric.kind === "sum") return index.sumFields.includes(metric.field) || index.avgFields.includes(metric.field);
-	if (metric.kind === "avg") return index.avgFields.includes(metric.field);
-	if (metric.kind === "min") return index.minFields.includes(metric.field);
-	return index.maxFields.includes(metric.field);
-};
-const pickAggregateIndex = (indexDefinitions, constrainedFields, metric) => {
-	let best = null;
-	for (const definition of indexDefinitions) {
-		if (!definition.fields.every((field) => constrainedFields.has(field))) continue;
-		const indexFieldSet = new Set(definition.fields);
-		if ([...constrainedFields].some((field) => !indexFieldSet.has(field))) continue;
-		if (!supportsMetric(definition, metric)) continue;
-		if (!best || definition.fields.length > best.fields.length) best = definition;
-	}
-	return best;
-};
-const pickRangeAggregateIndex = (indexDefinitions, constraints, constrainedFields, rangeFieldName, metric) => {
-	let best = null;
-	for (const definition of indexDefinitions) {
-		if (!supportsMetric(definition, metric)) continue;
-		const usesImplicitCreationTimeSuffix = rangeFieldName === INTERNAL_CREATION_TIME_FIELD;
-		const rangeFieldPosition = usesImplicitCreationTimeSuffix ? definition.fields.length : definition.fields.indexOf(rangeFieldName);
-		if (rangeFieldPosition < 0) continue;
-		const indexFieldSet = new Set(definition.fields);
-		if (usesImplicitCreationTimeSuffix) indexFieldSet.add(INTERNAL_CREATION_TIME_FIELD);
-		if ([...constrainedFields].some((field) => !indexFieldSet.has(field))) continue;
-		const prefixFields = definition.fields.slice(0, rangeFieldPosition);
-		if (prefixFields.some((field) => {
-			return !constraints.get(field)?.values;
-		})) continue;
-		if (prefixFields.some((field) => {
-			const fieldConstraint = constraints.get(field);
-			return Boolean(fieldConstraint?.rangeComparisons?.length);
-		})) continue;
-		if (!best || prefixFields.length > best.prefixFields.length || prefixFields.length === best.prefixFields.length && definition.fields.length > best.definition.fields.length) best = {
-			definition,
-			prefixFields
-		};
-	}
-	return best;
-};
-const buildCandidateKeys = (fields, constraints, index = 0, current = [], output = []) => {
-	if (index >= fields.length) {
-		output.push([...current]);
-		return output;
-	}
-	const values = constraints[fields[index]] ?? [];
-	for (const value of values) {
-		current.push(value);
-		buildCandidateKeys(fields, constraints, index + 1, current, output);
-		current.pop();
-	}
-	return output;
-};
-const getAggregateCartesianMaxKeys = (tableConfig) => {
-	const value = tableConfig.defaults?.aggregateCartesianMaxKeys;
-	if (typeof value === "number" && Number.isFinite(value) && value >= 1) return Math.floor(value);
-	return DEFAULT_AGGREGATE_CARTESIAN_MAX_KEYS$1;
-};
-const getAggregateWorkBudget = (tableConfig) => {
-	const value = tableConfig.defaults?.aggregateWorkBudget;
-	if (typeof value === "number" && Number.isFinite(value) && value >= 1) return Math.floor(value);
-	return DEFAULT_AGGREGATE_WORK_BUDGET$1;
-};
-const countCartesianCombinations = (fields, constraints, maxCount) => {
-	if (fields.length === 0) return 1;
-	let total = 1;
-	for (const field of fields) {
-		const values = constraints[field] ?? [];
-		if (values.length === 0) return 0;
-		const threshold = Math.max(1, maxCount);
-		const maxBeforeMultiply = Math.floor(threshold / values.length);
-		if (total > maxBeforeMultiply) return threshold + 1;
-		total *= values.length;
-	}
-	return total;
-};
-const enforceCartesianExpansionGuards = (options) => {
-	const cartesianMaxKeys = getAggregateCartesianMaxKeys(options.tableConfig);
-	const workBudget = getAggregateWorkBudget(options.tableConfig);
-	const workUnitsPerCombination = Math.max(1, options.workUnitsPerCombination);
-	const maxCombinationsByWork = Math.max(1, Math.floor(workBudget / workUnitsPerCombination));
-	const maxTrackedCombinations = Math.max(cartesianMaxKeys, maxCombinationsByWork);
-	const combinations = countCartesianCombinations(options.fields, options.fieldValues, maxTrackedCombinations);
-	if (combinations === 0) return;
-	if (combinations > cartesianMaxKeys) throw createFilterError(options.codes, options.methodName, `expands IN filters to ${combinations} key combinations on aggregateIndex '${options.indexName}', exceeding aggregateCartesianMaxKeys (${cartesianMaxKeys}). Reduce IN list sizes, split the query, add a narrower aggregateIndex, or increase defineSchema(..., { defaults: { aggregateCartesianMaxKeys } }).`);
-	const estimatedWork = combinations * workUnitsPerCombination;
-	if (estimatedWork > workBudget) throw createFilterError(options.codes, options.methodName, `estimated ${options.workLabel} is ${estimatedWork} units on aggregateIndex '${options.indexName}', exceeding aggregateWorkBudget (${workBudget}). Reduce IN fan-out, split the query, or increase defineSchema(..., { defaults: { aggregateWorkBudget } }).`);
-};
-const hasLogicalOr = (where) => {
-	if (Object.hasOwn(where, "OR")) return true;
-	const andEntries = where.AND;
-	if (!Array.isArray(andEntries)) return false;
-	return andEntries.some((entry) => isPlainObject(entry) && hasLogicalOr(entry));
-};
-const combineDnfBranches = (options) => {
-	const { left, right, maxBranches, codes, methodName } = options;
-	if (left.length === 0 || right.length === 0) return [];
-	const threshold = Math.max(1, maxBranches);
-	const maxBeforeMultiply = Math.floor(threshold / right.length);
-	if (left.length > maxBeforeMultiply) throw createFilterError(codes, methodName, `OR rewrite expands to ${left.length * right.length} branches, exceeding aggregateCartesianMaxKeys (${threshold}). Reduce OR fan-out, split the query, or increase defineSchema(..., { defaults: { aggregateCartesianMaxKeys } }).`);
-	const combined = [];
-	for (const leftBranch of left) for (const rightBranch of right) combined.push([...leftBranch, ...rightBranch]);
-	return combined;
-};
-const expandWhereToFiniteDnf = (options) => {
-	const { where, maxBranches, codes, methodName } = options;
-	if (Object.hasOwn(where, "NOT")) throw createFilterError(codes, methodName, "NOT is not supported in no-scan aggregate/count filters.");
-	if (Object.hasOwn(where, "RAW")) throw createFilterError(codes, methodName, "does not support RAW filters.");
-	const scalarClause = {};
-	for (const [key, value] of Object.entries(where)) {
-		if (key === "AND" || key === "OR") continue;
-		scalarClause[key] = value;
-	}
-	let branches = [[]];
-	if (Object.keys(scalarClause).length > 0) branches = branches.map((branch) => [...branch, scalarClause]);
-	if (Object.hasOwn(where, "AND")) {
-		const andEntries = where.AND;
-		if (!Array.isArray(andEntries)) throw createFilterError(codes, methodName, "AND must be an array of filter objects.");
-		for (const entry of andEntries) {
-			if (!isPlainObject(entry)) throw createFilterError(codes, methodName, "AND entries must be objects.");
-			const entryBranches = expandWhereToFiniteDnf({
-				where: entry,
-				maxBranches,
-				codes,
-				methodName
-			});
-			branches = combineDnfBranches({
-				left: branches,
-				right: entryBranches,
-				maxBranches,
-				codes,
-				methodName
-			});
-		}
-	}
-	if (Object.hasOwn(where, "OR")) {
-		const orEntries = where.OR;
-		if (!Array.isArray(orEntries) || orEntries.length === 0) throw createFilterError(codes, methodName, "OR must be a non-empty array of filter objects.");
-		const orBranches = [];
-		for (const entry of orEntries) {
-			if (!isPlainObject(entry)) throw createFilterError(codes, methodName, "OR entries must be objects.");
-			const expanded = expandWhereToFiniteDnf({
-				where: entry,
-				maxBranches,
-				codes,
-				methodName
-			});
-			orBranches.push(...expanded);
-			if (orBranches.length > maxBranches) throw createFilterError(codes, methodName, `OR rewrite expands to ${orBranches.length} branches, exceeding aggregateCartesianMaxKeys (${maxBranches}). Reduce OR fan-out, split the query, or increase defineSchema(..., { defaults: { aggregateCartesianMaxKeys } }).`);
-		}
-		branches = combineDnfBranches({
-			left: branches,
-			right: orBranches,
-			maxBranches,
-			codes,
-			methodName
-		});
-	}
-	return branches;
-};
-const branchToWhere = (branch) => {
-	if (branch.length === 0) return {};
-	if (branch.length === 1) return branch[0];
-	return { AND: branch };
-};
-const compileFiniteOrUnionPlan = (options) => {
-	const { tableConfig, where, metric, aggregateIndexes, codes, methodName, throwNotIndexed } = options;
-	if (!hasLogicalOr(where)) return null;
-	const cartesianMaxKeys = getAggregateCartesianMaxKeys(tableConfig);
-	const workBudget = getAggregateWorkBudget(tableConfig);
-	const branches = expandWhereToFiniteDnf({
-		where,
-		maxBranches: Math.max(1, Math.min(cartesianMaxKeys, workBudget)),
-		codes,
-		methodName
-	});
-	if (branches.length === 0) throw createFilterError(codes, methodName, "OR must include at least one branch.");
-	const dedupedKeyCandidates = /* @__PURE__ */ new Map();
-	let selectedIndexName = null;
-	let selectedIndexFields = null;
-	let totalBranchCandidates = 0;
-	for (const branch of branches) {
-		const branchWhere = branchToWhere(branch);
-		const constraints = /* @__PURE__ */ new Map();
-		parseWhereObject(branchWhere, tableConfig, constraints, codes, methodName);
-		normalizeConstraints(constraints, codes, methodName);
-		if ([...constraints.entries()].filter(([, constraint]) => (constraint.rangeComparisons?.length ?? 0) > 0).map(([field]) => field).length > 0) throw createFilterError(codes, methodName, "OR rewrite supports finite eq/in/isNull branches only in v1. Range operators inside OR are not supported.");
-		const matchedIndex = pickAggregateIndex(aggregateIndexes, new Set(constraints.keys()), metric);
-		if (!matchedIndex) throwNotIndexed();
-		const exactIndex = matchedIndex;
-		if (selectedIndexName === null || selectedIndexFields === null) {
-			selectedIndexName = exactIndex.name;
-			selectedIndexFields = exactIndex.fields;
-		} else if (selectedIndexName !== exactIndex.name || selectedIndexFields.length !== exactIndex.fields.length || selectedIndexFields.some((field, index) => field !== exactIndex.fields[index])) throw createFilterError(codes, methodName, `OR branches must resolve to a single aggregateIndex. Found incompatible branches between '${selectedIndexName}' and '${exactIndex.name}'.`);
-		const rawFieldValues = constraintsToValueRecord(constraints);
-		const fieldValues = Object.fromEntries(exactIndex.fields.map((field) => [field, rawFieldValues[field] ?? []]));
-		enforceCartesianExpansionGuards({
-			tableConfig,
-			codes,
-			methodName,
-			indexName: exactIndex.name,
-			fields: exactIndex.fields,
-			fieldValues,
-			workUnitsPerCombination: 1,
-			workLabel: "OR-branch key lookup work"
-		});
-		if (Object.values(fieldValues).some((values) => values.length === 0)) continue;
-		const branchCandidates = buildCandidateKeys(exactIndex.fields, fieldValues);
-		totalBranchCandidates += branchCandidates.length;
-		for (const keyParts of branchCandidates) dedupedKeyCandidates.set(serializeCountKeyParts(keyParts), keyParts);
-	}
-	if (!selectedIndexName || !selectedIndexFields) throw createFilterError(codes, methodName, "OR rewrite did not resolve to any index-plannable branch.");
-	const uniqueKeyCount = dedupedKeyCandidates.size;
-	if (uniqueKeyCount > cartesianMaxKeys) throw createFilterError(codes, methodName, `OR rewrite expands to ${uniqueKeyCount} unique key combinations on aggregateIndex '${selectedIndexName}', exceeding aggregateCartesianMaxKeys (${cartesianMaxKeys}). Reduce OR fan-out, split the query, or increase defineSchema(..., { defaults: { aggregateCartesianMaxKeys } }).`);
-	const estimatedWork = branches.length + totalBranchCandidates;
-	if (estimatedWork > workBudget) throw createFilterError(codes, methodName, `estimated OR rewrite work is ${estimatedWork} units on aggregateIndex '${selectedIndexName}', exceeding aggregateWorkBudget (${workBudget}). Reduce OR fan-out, split the query, or increase defineSchema(..., { defaults: { aggregateWorkBudget } }).`);
-	return {
-		tableName: tableConfig.name,
-		indexName: selectedIndexName,
-		indexFields: selectedIndexFields,
-		fieldValues: {},
-		keyCandidates: [...dedupedKeyCandidates.values()],
-		rangeConstraint: null,
-		postFieldValues: {},
-		metric
-	};
-};
-const serializeCountKeyParts = (parts) => serializeStable(parts);
-const compileAggregatePlan = (tableConfig, where, metric, codes, methodName) => {
-	const normalizedWhere = where ?? {};
-	if (!isPlainObject(normalizedWhere)) throw createFilterError(codes, methodName, "where must be an object filter.");
-	const aggregateIndexes = getAggregateIndexDefinitions(tableConfig);
-	const throwNotIndexed = (fieldList) => {
-		if (metric.kind === "count") throw createError(codes.NOT_INDEXED, `No matching aggregateIndex found for count() on '${tableConfig.name}'. Add an aggregateIndex for [${fieldList}] and run aggregateBackfill.`);
-		if (metric.kind === "countField") throw createError(codes.NOT_INDEXED, `No matching aggregateIndex found for count(select: { ${metric.field}: true }) on '${tableConfig.name}'. Declare aggregateIndex(...).on(...).count(...) and run aggregateBackfill.`);
-		if (metric.kind === "avg") throw createError(codes.NOT_INDEXED, `No matching aggregateIndex found for avg('${metric.field}') on '${tableConfig.name}'. Declare aggregateIndex(...).on(...).avg(...) (or .all() for unfiltered) and run aggregateBackfill.`);
-		throw createError(codes.NOT_INDEXED, `No matching aggregateIndex found for ${metric.kind}('${metric.field}') on '${tableConfig.name}'. Declare aggregateIndex(...).on(...).${metric.kind}(...) (or .all() for unfiltered) and run aggregateBackfill.`);
-	};
-	const finiteOrUnionPlan = compileFiniteOrUnionPlan({
-		tableConfig,
-		where: normalizedWhere,
-		metric,
-		aggregateIndexes,
-		codes,
-		methodName,
-		throwNotIndexed: () => throwNotIndexed("OR branches")
-	});
-	if (finiteOrUnionPlan) return finiteOrUnionPlan;
-	const constraints = /* @__PURE__ */ new Map();
-	parseWhereObject(rewriteSafeOrWhere({
-		where: normalizedWhere,
-		tableConfig,
-		codes,
-		methodName
-	}), tableConfig, constraints, codes, methodName);
-	normalizeConstraints(constraints, codes, methodName);
-	const constrainedFields = new Set(constraints.keys());
-	const rangeFields = [...constraints.entries()].filter(([, constraint]) => (constraint.rangeComparisons?.length ?? 0) > 0).map(([field]) => field);
-	if (rangeFields.length > 1) throw createFilterError(codes, methodName, `supports range operators on at most one field in v1. Found [${rangeFields.join(", ")}].`);
-	const fieldList = [...constrainedFields].join(", ");
-	if (rangeFields.length === 0) {
-		const matchedIndex = pickAggregateIndex(aggregateIndexes, constrainedFields, metric);
-		if (!matchedIndex) throwNotIndexed(fieldList);
-		const exactIndex = matchedIndex;
-		const rawFieldValues = constraintsToValueRecord(constraints);
-		const fieldValues = Object.fromEntries(exactIndex.fields.map((field) => [field, rawFieldValues[field] ?? []]));
-		enforceCartesianExpansionGuards({
-			tableConfig,
-			codes,
-			methodName,
-			indexName: exactIndex.name,
-			fields: exactIndex.fields,
-			fieldValues,
-			workUnitsPerCombination: 1,
-			workLabel: "key lookup work"
-		});
-		for (const values of Object.values(fieldValues)) if (values.length === 0) return {
-			tableName: tableConfig.name,
-			indexName: exactIndex.name,
-			indexFields: exactIndex.fields,
-			fieldValues,
-			rangeConstraint: null,
-			postFieldValues: {},
-			metric
-		};
-		return {
-			tableName: tableConfig.name,
-			indexName: exactIndex.name,
-			indexFields: exactIndex.fields,
-			fieldValues,
-			rangeConstraint: null,
-			postFieldValues: {},
-			metric
-		};
-	}
-	const rangeFieldName = rangeFields[0];
-	const rangeComparisons = constraints.get(rangeFieldName)?.rangeComparisons ?? [];
-	const matchedRangeIndex = pickRangeAggregateIndex(aggregateIndexes, constraints, constrainedFields, rangeFieldName, metric);
-	if (!matchedRangeIndex) throwNotIndexed(fieldList);
-	const rangeIndex = matchedRangeIndex;
-	const prefixFieldValues = Object.fromEntries(rangeIndex.prefixFields.map((field) => [field, [...constraints.get(field)?.values?.values() ?? []]]));
-	const postFieldValues = {};
-	for (const field of rangeIndex.definition.fields) {
-		if (field === rangeFieldName || rangeIndex.prefixFields.includes(field)) continue;
-		const values = constraints.get(field)?.values;
-		if (!values) continue;
-		postFieldValues[field] = [...values.values()];
-	}
-	const rangeWorkUnits = RANGE_PREFIX_WORK_UNIT_BASE + Object.keys(postFieldValues).length;
-	enforceCartesianExpansionGuards({
-		tableConfig,
-		codes,
-		methodName,
-		indexName: rangeIndex.definition.name,
-		fields: rangeIndex.prefixFields,
-		fieldValues: prefixFieldValues,
-		workUnitsPerCombination: rangeWorkUnits,
-		workLabel: "range-prefix work"
-	});
-	return {
-		tableName: tableConfig.name,
-		indexName: rangeIndex.definition.name,
-		indexFields: rangeIndex.definition.fields,
-		fieldValues: prefixFieldValues,
-		rangeConstraint: {
-			fieldName: rangeFieldName,
-			comparisons: rangeComparisons,
-			prefixFields: rangeIndex.prefixFields,
-			workBudget: getAggregateWorkBudget(tableConfig),
-			filterErrorCode: codes.FILTER_UNSUPPORTED,
-			methodName
-		},
-		postFieldValues,
-		metric
-	};
-};
-const compileCountQueryPlan = (tableConfig, where) => {
-	const plan = compileAggregatePlan(tableConfig, where, { kind: "count" }, COUNT_ERROR, "count()");
-	return {
-		tableName: plan.tableName,
-		indexName: plan.indexName,
-		indexFields: plan.indexFields,
-		fieldValues: plan.fieldValues,
-		keyCandidates: plan.keyCandidates,
-		rangeConstraint: plan.rangeConstraint,
-		postFieldValues: plan.postFieldValues
-	};
-};
-const compileCountFieldQueryPlan = (tableConfig, where, field) => compileAggregatePlan(tableConfig, where, {
-	kind: "countField",
-	field
-}, COUNT_ERROR, `count(select: { ${field}: true })`);
-const compileAggregateQueryPlan = (tableConfig, where, metric) => compileAggregatePlan(tableConfig, where, metric, AGGREGATE_ERROR, (() => {
-	if (metric.kind === "countField") return `count(select: { ${metric.field}: true })`;
-	if (metric.kind === "avg") return `avg('${metric.field}')`;
-	return `${metric.kind}()`;
-})());
-const deepEquals = (left, right) => serializeStable(left) === serializeStable(right);
-const normalizeSumValues = (values) => {
-	const output = {};
-	for (const [field, value] of Object.entries(values)) if (typeof value === "number" && Number.isFinite(value)) output[field] = value;
-	return output;
-};
-const normalizeNonNullCountValues = (values) => {
-	const output = {};
-	for (const [field, value] of Object.entries(values)) if (typeof value === "number" && Number.isFinite(value)) output[field] = value;
-	return output;
-};
-const normalizeExtremaValues = (values) => ({ ...values });
-const mergeSumValues = (baseValues, deltaValues) => {
-	const merged = { ...baseValues };
-	for (const [field, delta] of Object.entries(deltaValues)) {
-		const next = (merged[field] ?? 0) + delta;
-		if (next === 0) {
-			delete merged[field];
-			continue;
-		}
-		merged[field] = next;
-	}
-	return merged;
-};
-const mergeCountValues = (baseValues, deltaValues) => {
-	const merged = { ...baseValues };
-	for (const [field, delta] of Object.entries(deltaValues)) {
-		const next = (merged[field] ?? 0) + delta;
-		if (next === 0) {
-			delete merged[field];
-			continue;
-		}
-		merged[field] = next;
-	}
-	return merged;
-};
-const negateSumValues = (values) => Object.fromEntries(Object.entries(values).map(([field, value]) => [field, -value]));
-const negateCountValues = (values) => Object.fromEntries(Object.entries(values).map(([field, value]) => [field, -value]));
-const listBucketsByHash = async (db, tableName, indexName, keyHash) => await db.query(AGGREGATE_BUCKET_TABLE).withIndex("by_table_index_hash", (q) => q.eq("tableKey", tableName).eq("indexName", indexName).eq("keyHash", keyHash)).collect();
-const getBucketByKey = async (db, tableName, indexName, keyParts) => {
-	return (await listBucketsByHash(db, tableName, indexName, serializeCountKeyParts(keyParts))).find((bucket) => deepEquals(bucket.keyParts, keyParts)) ?? null;
-};
-const listBucketsByHashPrefix = async (db, tableName, indexName, scan, limit) => await db.query(AGGREGATE_BUCKET_TABLE).withIndex("by_table_index_hash", (q) => {
-	const scoped = q.eq("tableKey", tableName).eq("indexName", indexName);
-	return (scan.after === void 0 ? scoped.gte("keyHash", scan.start) : scoped.gt("keyHash", scan.after)).lt("keyHash", scan.end);
-}).take(limit);
-const getExtremaByValue = async (db, tableName, indexName, keyHash, fieldName, value) => {
-	const valueHash = serializeStable(value);
-	return (await db.query(AGGREGATE_EXTREMA_TABLE).withIndex("by_table_index_hash_field_value", (q) => q.eq("tableKey", tableName).eq("indexName", indexName).eq("keyHash", keyHash).eq("fieldName", fieldName).eq("valueHash", valueHash)).collect()).find((row) => deepEquals(row.value, value)) ?? null;
-};
-const takeMembersForIndex = async (db, tableName, indexName, limit) => await db.query(AGGREGATE_MEMBER_TABLE).withIndex("by_kind_table_index", (q) => q.eq("kind", AGGREGATE_STATE_KIND_METRIC).eq("tableKey", tableName).eq("indexName", indexName)).take(limit);
-const takeBucketsForIndex = async (db, tableName, indexName, limit) => await db.query(AGGREGATE_BUCKET_TABLE).withIndex("by_table_index", (q) => q.eq("tableKey", tableName).eq("indexName", indexName)).take(limit);
-const takeExtremaForIndex = async (db, tableName, indexName, limit) => await db.query(AGGREGATE_EXTREMA_TABLE).withIndex("by_table_index", (q) => q.eq("tableKey", tableName).eq("indexName", indexName)).take(limit);
-const applyBucketDelta = async (db, tableName, indexName, keyParts, deltaCount, deltaSums, deltaNonNullCounts) => {
-	if (deltaCount === 0 && Object.keys(deltaSums).length === 0 && Object.keys(deltaNonNullCounts).length === 0) return;
-	const existing = await getBucketByKey(db, tableName, indexName, keyParts);
-	const now = Date.now();
-	if (!existing) {
-		if (deltaCount < 0) return;
-		await db.insert(AGGREGATE_BUCKET_TABLE, {
-			tableKey: tableName,
-			indexName,
-			keyHash: serializeCountKeyParts(keyParts),
-			keyParts,
-			count: deltaCount,
-			sumValues: deltaSums,
-			nonNullCountValues: deltaNonNullCounts,
-			updatedAt: now
-		});
-		return;
-	}
-	const nextCount = existing.count + deltaCount;
-	if (nextCount <= 0) {
-		await db.delete(AGGREGATE_BUCKET_TABLE, existing._id);
-		return;
-	}
-	const nextSumValues = mergeSumValues(normalizeSumValues(existing.sumValues), deltaSums);
-	const nextNonNullCountValues = mergeCountValues(normalizeNonNullCountValues(existing.nonNullCountValues), deltaNonNullCounts);
-	await db.patch(AGGREGATE_BUCKET_TABLE, existing._id, {
-		count: nextCount,
-		sumValues: nextSumValues,
-		nonNullCountValues: nextNonNullCountValues,
-		updatedAt: now
-	});
-};
-const encodeNumberSortKey = (value) => {
-	const view = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(8));
-	view.setFloat64(0, value);
-	let bits = view.getBigUint64(0);
-	if ((bits & FLOAT64_SIGN_BIT) !== 0n) bits = ~bits & FLOAT64_MASK;
-	else bits |= FLOAT64_SIGN_BIT;
-	return bits.toString(16).padStart(16, "0");
-};
-const toComparableSortKey = (value) => {
-	if (typeof value === "number") {
-		if (!Number.isFinite(value)) throw createError(AGGREGATE_ERROR.FILTER_UNSUPPORTED, `Aggregate min/max only support finite numbers, strings, and booleans. Received ${String(value)}.`);
-		return `n:${encodeNumberSortKey(value)}`;
-	}
-	if (typeof value === "string") return `s:${value}`;
-	if (typeof value === "boolean") return `b:${value ? "1" : "0"}`;
-	throw createError(AGGREGATE_ERROR.FILTER_UNSUPPORTED, `Aggregate min/max only support finite numbers, strings, and booleans. Received '${typeof value}'.`);
-};
-const compareSortableValues = (left, right) => {
-	const leftKey = toComparableSortKey(left);
-	const rightKey = toComparableSortKey(right);
-	if (leftKey < rightKey) return -1;
-	if (leftKey > rightKey) return 1;
-	return 0;
-};
-const applyExtremaDelta = async (db, tableName, indexName, keyHash, fieldName, value, deltaCount) => {
-	if (deltaCount === 0) return;
-	const existing = await getExtremaByValue(db, tableName, indexName, keyHash, fieldName, value);
-	const now = Date.now();
-	if (!existing) {
-		if (deltaCount < 0) return;
-		await db.insert(AGGREGATE_EXTREMA_TABLE, {
-			tableKey: tableName,
-			indexName,
-			keyHash,
-			fieldName,
-			valueHash: serializeStable(value),
-			value,
-			sortKey: toComparableSortKey(value),
-			count: deltaCount,
-			updatedAt: now
-		});
-		return;
-	}
-	const nextCount = existing.count + deltaCount;
-	if (nextCount <= 0) {
-		await db.delete(AGGREGATE_EXTREMA_TABLE, existing._id);
-		return;
-	}
-	await db.patch(AGGREGATE_EXTREMA_TABLE, existing._id, {
-		count: nextCount,
-		updatedAt: now
-	});
-};
-const buildKeyHashPrefixBounds = (prefixParts) => {
-	if (prefixParts.length === 0) return {
-		start: "[",
-		end: "[￿"
-	};
-	const start = `${serializeCountKeyParts(prefixParts).slice(0, -1)},`;
-	return {
-		start,
-		end: `${start}\uffff`
-	};
-};
-const matchesKeyPrefix = (keyParts, prefixParts) => prefixParts.every((value, index) => deepEquals(keyParts[index], value));
-/**
-* A prefix scan only bounds the key tuple's leading equality fields, so every
-* bucket it returns still has to clear the range predicate and any equality
-* field that sits after the range field in the index.
-*/
-const matchesRangePlanBucket = (options) => {
-	const { bucket, indexFields } = options;
-	if (!matchesKeyPrefix(bucket.keyParts, options.prefixParts)) return false;
-	if (!matchesRangeComparisons(bucket.keyParts[options.rangeFieldIndex], options.comparisons)) return false;
-	for (const [field, allowedValues] of Object.entries(options.postFieldSets)) {
-		const fieldIndex = indexFields.indexOf(field);
-		if (fieldIndex < 0) return false;
-		if (!allowedValues.has(serializeStable(bucket.keyParts[fieldIndex]))) return false;
-	}
-	return true;
-};
-const readPlanBuckets = async (db, plan) => {
-	if (!plan.rangeConstraint) return (await mapWithConcurrency(plan.keyCandidates ?? buildCandidateKeys(plan.indexFields, plan.fieldValues), AGGREGATE_BUCKET_READ_CONCURRENCY, (keyParts) => getBucketByKey(db, plan.tableName, plan.indexName, keyParts))).filter((bucket) => bucket !== null);
-	const prefixCandidates = buildCandidateKeys(plan.rangeConstraint.prefixFields, plan.fieldValues);
-	const rangeFieldIndex = plan.indexFields.indexOf(plan.rangeConstraint.fieldName);
-	if (rangeFieldIndex < 0) return [];
-	const postFieldSets = Object.fromEntries(Object.entries(plan.postFieldValues).map(([field, values]) => [field, toConstraintSet(values)]));
-	const workBudget = plan.rangeConstraint.workBudget ?? DEFAULT_AGGREGATE_WORK_BUDGET$1;
-	const scanLimit = workBudget + 1;
-	let pending = prefixCandidates.map((prefixParts) => ({
-		prefixParts,
-		...buildKeyHashPrefixBounds(prefixParts)
-	}));
-	const matchedById = /* @__PURE__ */ new Map();
-	let scanned = 0;
-	while (pending.length > 0 && scanned < scanLimit) {
-		const remaining = scanLimit - scanned;
-		const batch = pending.slice(0, Math.min(AGGREGATE_BUCKET_READ_CONCURRENCY, remaining));
-		const share = Math.floor(remaining / batch.length);
-		const pages = await mapWithConcurrency(batch, AGGREGATE_BUCKET_READ_CONCURRENCY, (scan) => listBucketsByHashPrefix(db, plan.tableName, plan.indexName, scan, share));
-		const next = pending.slice(batch.length);
-		for (let index = 0; index < batch.length; index += 1) {
-			const scan = batch[index];
-			const page = pages[index];
-			scanned += page.length;
-			for (const bucket of page) if (matchesRangePlanBucket({
-				bucket,
-				prefixParts: scan.prefixParts,
-				indexFields: plan.indexFields,
-				rangeFieldIndex,
-				comparisons: plan.rangeConstraint.comparisons,
-				postFieldSets
-			})) matchedById.set(String(bucket._id), bucket);
-			const lastBucket = page.at(-1);
-			if (page.length < share || !lastBucket) continue;
-			next.push({
-				...scan,
-				after: lastBucket.keyHash
-			});
-		}
-		pending = next;
-	}
-	if (scanned > workBudget) {
-		const fanOut = prefixCandidates.length > 1 ? ` across ${prefixCandidates.length} equality-prefix combinations` : "";
-		throw createError(plan.rangeConstraint.filterErrorCode ?? AGGREGATE_ERROR.FILTER_UNSUPPORTED, `${plan.rangeConstraint.methodName ?? "aggregate()"} range filter on '${plan.rangeConstraint.fieldName}' scans more than ${workBudget} aggregate buckets${fanOut} on aggregateIndex '${plan.indexName}'. Narrow the equality prefix, shrink the IN lists it expands to, reduce the range field's cardinality, add a narrower aggregateIndex, or increase defineSchema(..., { defaults: { aggregateWorkBudget } }).`);
-	}
-	const buckets = [...matchedById.values()];
-	buckets[RANGE_WORK_STATE] = {
-		scannedBuckets: scanned,
-		reservedExtremaReads: 0
-	};
-	return buckets;
-};
-const sortFieldValueRecord = (values) => Object.fromEntries(Object.keys(values).sort().map((field) => [field, values[field] ?? []]));
-const getPlanBucketCacheKey = (plan) => serializeStable({
-	tableName: plan.tableName,
-	indexName: plan.indexName,
-	indexFields: plan.indexFields,
-	fieldValues: sortFieldValueRecord(plan.fieldValues),
-	keyCandidates: plan.keyCandidates ?? null,
-	rangeConstraint: plan.rangeConstraint ? {
-		fieldName: plan.rangeConstraint.fieldName,
-		comparisons: [...plan.rangeConstraint.comparisons],
-		prefixFields: plan.rangeConstraint.prefixFields
-	} : null,
-	postFieldValues: sortFieldValueRecord(plan.postFieldValues)
-});
-const readPlanBucketsWithCache = async (db, plan, bucketCache) => {
-	if (!bucketCache) return await readPlanBuckets(db, plan);
-	const cacheKey = getPlanBucketCacheKey(plan);
-	const existing = bucketCache.get(cacheKey);
-	if (existing) return await existing;
-	const pending = readPlanBuckets(db, plan);
-	bucketCache.set(cacheKey, pending);
-	try {
-		return await pending;
-	} catch (error) {
-		bucketCache.delete(cacheKey);
-		throw error;
-	}
-};
-const readCountFromBuckets = async (db, plan, bucketCache) => {
-	return (await readPlanBucketsWithCache(db, plan, bucketCache)).reduce((sum, bucket) => sum + bucket.count, 0);
-};
-const readSumFromBuckets = async (db, plan, bucketCache) => {
-	if (plan.metric.kind !== "sum") throw new Error("readSumFromBuckets() requires a sum aggregate plan.");
-	let total = 0;
-	let totalNonNull = 0;
-	const buckets = await readPlanBucketsWithCache(db, plan, bucketCache);
-	for (const bucket of buckets) {
-		const sumValues = normalizeSumValues(bucket.sumValues);
-		const countValues = normalizeNonNullCountValues(bucket.nonNullCountValues);
-		total += sumValues[plan.metric.field] ?? 0;
-		totalNonNull += countValues[plan.metric.field] ?? 0;
-	}
-	if (totalNonNull === 0) return null;
-	return total;
-};
-const readCountFieldFromBuckets = async (db, plan, bucketCache) => {
-	if (plan.metric.kind !== "countField") throw new Error("readCountFieldFromBuckets() requires a countField aggregate plan.");
-	let total = 0;
-	const buckets = await readPlanBucketsWithCache(db, plan, bucketCache);
-	for (const bucket of buckets) {
-		const countValues = normalizeNonNullCountValues(bucket.nonNullCountValues);
-		total += countValues[plan.metric.field] ?? 0;
-	}
-	return total;
-};
-const readAverageFromBuckets = async (db, plan, bucketCache) => {
-	if (plan.metric.kind !== "avg") throw new Error("readAverageFromBuckets() requires an avg aggregate plan.");
-	let totalSum = 0;
-	let totalNonNull = 0;
-	const buckets = await readPlanBucketsWithCache(db, plan, bucketCache);
-	for (const bucket of buckets) {
-		const sumValues = normalizeSumValues(bucket.sumValues);
-		const countValues = normalizeNonNullCountValues(bucket.nonNullCountValues);
-		totalSum += sumValues[plan.metric.field] ?? 0;
-		totalNonNull += countValues[plan.metric.field] ?? 0;
-	}
-	if (totalNonNull === 0) return null;
-	return totalSum / totalNonNull;
-};
-const readKeyExtrema = async (db, params) => {
-	let query = db.query(AGGREGATE_EXTREMA_TABLE).withIndex("by_table_index_hash_field_sort", (q) => q.eq("tableKey", params.tableName).eq("indexName", params.indexName).eq("keyHash", params.keyHash).eq("fieldName", params.fieldName));
-	if (params.kind === "max") query = query.order("desc");
-	return (await query.take(1))[0]?.value ?? null;
-};
-const readExtremaFromBuckets = async (db, plan, bucketCache) => {
-	if (plan.metric.kind !== "min" && plan.metric.kind !== "max") throw new Error("readExtremaFromBuckets() requires a min/max aggregate plan.");
-	let selected = null;
-	const buckets = await readPlanBucketsWithCache(db, plan, bucketCache);
-	const metric = plan.metric;
-	const rangeWork = buckets[RANGE_WORK_STATE];
-	if (rangeWork && plan.rangeConstraint) {
-		const workBudget = plan.rangeConstraint.workBudget ?? DEFAULT_AGGREGATE_WORK_BUDGET$1;
-		const requestedWork = buckets.length;
-		const totalWork = rangeWork.scannedBuckets + rangeWork.reservedExtremaReads + requestedWork;
-		if (totalWork > workBudget) throw createError(plan.rangeConstraint.filterErrorCode ?? AGGREGATE_ERROR.FILTER_UNSUPPORTED, `${plan.rangeConstraint.methodName ?? "aggregate()"} range filter on '${plan.rangeConstraint.fieldName}' needs ${totalWork} aggregate work units (${rangeWork.scannedBuckets} bucket reads and ${rangeWork.reservedExtremaReads + requestedWork} extrema reads), exceeding aggregateWorkBudget (${workBudget}) on aggregateIndex '${plan.indexName}'. Narrow the range, add a narrower aggregateIndex, or increase defineSchema(..., { defaults: { aggregateWorkBudget } }).`);
-		rangeWork.reservedExtremaReads += requestedWork;
-	}
-	const values = await mapWithConcurrency(buckets, AGGREGATE_BUCKET_READ_CONCURRENCY, (bucket) => readKeyExtrema(db, {
-		tableName: plan.tableName,
-		indexName: plan.indexName,
-		keyHash: bucket.keyHash,
-		fieldName: metric.field,
-		kind: metric.kind
-	}));
-	for (const value of values) {
-		if (value === null || value === void 0) continue;
-		if (selected === null) {
-			selected = value;
-			continue;
-		}
-		const comparison = compareSortableValues(value, selected);
-		if (plan.metric.kind === "min" && comparison < 0) {
-			selected = value;
-			continue;
-		}
-		if (plan.metric.kind === "max" && comparison > 0) selected = value;
-	}
-	return selected;
-};
-const getMemberByDoc = async (db, tableName, indexName, docId) => {
-	return (await db.query(AGGREGATE_MEMBER_TABLE).withIndex("by_kind_table_index_doc", (q) => q.eq("kind", AGGREGATE_STATE_KIND_METRIC).eq("tableKey", tableName).eq("indexName", indexName).eq("docId", docId)).collect())[0] ?? null;
-};
-const isComparableAggregateValue = (value) => {
-	if (typeof value === "number") return Number.isFinite(value);
-	return typeof value === "string" || typeof value === "boolean";
-};
-const computeAggregateMetricValues = (doc, definition) => {
-	const sumValues = {};
-	for (const field of [...definition.sumFields, ...definition.avgFields]) {
-		const value = doc[field];
-		if (value === null || value === void 0) continue;
-		if (typeof value !== "number" || !Number.isFinite(value)) throw createError(AGGREGATE_ERROR.FILTER_UNSUPPORTED, `aggregateIndex '${definition.name}' sum('${field}') requires finite number values.`);
-		sumValues[field] = value;
-	}
-	const nonNullCountValues = {};
-	for (const field of [
-		...definition.countFields,
-		...definition.sumFields,
-		...definition.avgFields
-	]) {
-		const value = doc[field];
-		if (value === null || value === void 0) continue;
-		nonNullCountValues[field] = 1;
-	}
-	const extremaFields = new Set([...definition.minFields, ...definition.maxFields]);
-	const extremaValues = {};
-	for (const field of extremaFields) {
-		const value = doc[field];
-		if (value === null || value === void 0) continue;
-		if (!isComparableAggregateValue(value)) throw createError(AGGREGATE_ERROR.FILTER_UNSUPPORTED, `aggregateIndex '${definition.name}' ${field} must be a finite number, string, or boolean for min/max.`);
-		extremaValues[field] = value;
-	}
-	return {
-		sumValues,
-		extremaValues,
-		nonNullCountValues
-	};
-};
-const toExtremaDeltas = (keyHash, values, delta) => Object.entries(values).map(([fieldName, value]) => ({
-	keyHash,
-	fieldName,
-	value,
-	delta
-}));
-const accumulateNumberValues = (target, source) => {
-	for (const [field, value] of Object.entries(source)) {
-		const next = (target[field] ?? 0) + value;
-		if (next === 0) {
-			delete target[field];
-			continue;
-		}
-		target[field] = next;
-	}
-};
-/**
-* Pure half of aggregate reconciliation: works out what a single document's
-* membership change implies, without touching the database. Callers batch these
-* and flush once so a page of documents sharing a key tuple writes its bucket
-* one time instead of once per document.
-*/
-const computeMembershipDelta = (existing, params) => {
-	const { tableName, indexName, docId, keyParts, metricValues } = params;
-	if (!keyParts || !metricValues) {
-		if (!existing) return {
-			buckets: [],
-			extrema: [],
-			member: { kind: "none" }
-		};
-		return {
-			buckets: [{
-				keyHash: serializeCountKeyParts(existing.keyParts),
-				keyParts: existing.keyParts,
-				deltaCount: -1,
-				deltaSums: negateSumValues(normalizeSumValues(existing.sumValues)),
-				deltaNonNullCounts: negateCountValues(normalizeNonNullCountValues(existing.nonNullCountValues))
-			}],
-			extrema: toExtremaDeltas(existing.keyHash, normalizeExtremaValues(existing.extremaValues), -1),
-			member: {
-				kind: "delete",
-				id: existing._id
-			}
-		};
-	}
-	const normalizedKeyParts = keyParts.map((part) => normalizeUndefined(part));
-	const keyHash = serializeCountKeyParts(normalizedKeyParts);
-	const now = Date.now();
-	const normalizedNextSumValues = normalizeSumValues(metricValues.sumValues);
-	const normalizedNextNonNullCountValues = normalizeNonNullCountValues(metricValues.nonNullCountValues);
-	const normalizedNextExtremaValues = normalizeExtremaValues(metricValues.extremaValues);
-	if (existing && existing.keyHash === keyHash && deepEquals(existing.keyParts, normalizedKeyParts) && deepEquals(normalizeSumValues(existing.sumValues), normalizedNextSumValues) && deepEquals(normalizeNonNullCountValues(existing.nonNullCountValues), normalizedNextNonNullCountValues) && deepEquals(normalizeExtremaValues(existing.extremaValues), normalizedNextExtremaValues)) return {
-		buckets: [],
-		extrema: [],
-		member: { kind: "none" }
-	};
-	const buckets = [];
-	const extrema = [];
-	if (existing) {
-		buckets.push({
-			keyHash: serializeCountKeyParts(existing.keyParts),
-			keyParts: existing.keyParts,
-			deltaCount: -1,
-			deltaSums: negateSumValues(normalizeSumValues(existing.sumValues)),
-			deltaNonNullCounts: negateCountValues(normalizeNonNullCountValues(existing.nonNullCountValues))
-		});
-		extrema.push(...toExtremaDeltas(existing.keyHash, normalizeExtremaValues(existing.extremaValues), -1));
-	}
-	buckets.push({
-		keyHash,
-		keyParts: normalizedKeyParts,
-		deltaCount: 1,
-		deltaSums: normalizedNextSumValues,
-		deltaNonNullCounts: normalizedNextNonNullCountValues
-	});
-	extrema.push(...toExtremaDeltas(keyHash, normalizedNextExtremaValues, 1));
-	const memberFields = {
-		kind: AGGREGATE_STATE_KIND_METRIC,
-		keyHash,
-		keyParts: normalizedKeyParts,
-		sumValues: normalizedNextSumValues,
-		nonNullCountValues: normalizedNextNonNullCountValues,
-		extremaValues: normalizedNextExtremaValues,
-		updatedAt: now
-	};
-	return {
-		buckets,
-		extrema,
-		member: existing ? {
-			kind: "patch",
-			id: existing._id,
-			doc: memberFields
-		} : {
-			kind: "insert",
-			doc: {
-				...memberFields,
-				tableKey: tableName,
-				indexName,
-				docId
-			}
-		}
-	};
-};
-const computeAggregateMembershipDelta = async (db, params) => {
-	return computeMembershipDelta(await getMemberByDoc(db, params.tableName, params.indexName, params.docId), params);
-};
-/**
-* Write half of aggregate reconciliation. Folds bucket deltas by key tuple and
-* extrema deltas by (keyHash, field, value) so each storage document is read and
-* written once regardless of how many source documents contributed to it.
-*/
-const flushAggregateMembershipDeltas = async (db, tableName, indexName, deltas) => {
-	const bucketDeltas = /* @__PURE__ */ new Map();
-	const extremaDeltas = /* @__PURE__ */ new Map();
-	for (const delta of deltas) {
-		for (const bucket of delta.buckets) {
-			const current = bucketDeltas.get(bucket.keyHash);
-			if (!current) {
-				bucketDeltas.set(bucket.keyHash, {
-					keyHash: bucket.keyHash,
-					keyParts: bucket.keyParts,
-					deltaCount: bucket.deltaCount,
-					deltaSums: { ...bucket.deltaSums },
-					deltaNonNullCounts: { ...bucket.deltaNonNullCounts }
-				});
-				continue;
-			}
-			current.deltaCount += bucket.deltaCount;
-			accumulateNumberValues(current.deltaSums, bucket.deltaSums);
-			accumulateNumberValues(current.deltaNonNullCounts, bucket.deltaNonNullCounts);
-		}
-		for (const entry of delta.extrema) {
-			const cacheKey = serializeStable([
-				entry.keyHash,
-				entry.fieldName,
-				serializeStable(entry.value)
-			]);
-			const current = extremaDeltas.get(cacheKey);
-			if (!current) {
-				extremaDeltas.set(cacheKey, { ...entry });
-				continue;
-			}
-			current.delta += entry.delta;
-		}
-	}
-	for (const bucket of bucketDeltas.values()) await applyBucketDelta(db, tableName, indexName, bucket.keyParts, bucket.deltaCount, bucket.deltaSums, bucket.deltaNonNullCounts);
-	for (const entry of extremaDeltas.values()) await applyExtremaDelta(db, tableName, indexName, entry.keyHash, entry.fieldName, entry.value, entry.delta);
-	for (const delta of deltas) {
-		const member = delta.member;
-		if (member.kind === "delete") {
-			await db.delete(AGGREGATE_MEMBER_TABLE, member.id);
-			continue;
-		}
-		if (member.kind === "patch") {
-			await db.patch(AGGREGATE_MEMBER_TABLE, member.id, member.doc);
-			continue;
-		}
-		if (member.kind === "insert") await db.insert(AGGREGATE_MEMBER_TABLE, member.doc);
-	}
-};
-/**
-* Single-document reconciliation. Flushes eagerly so user code reading an
-* aggregate later in the same mutation sees its own writes.
-*/
-const reconcileAggregateMembership = async (db, params) => {
-	const delta = await computeAggregateMembershipDelta(db, params);
-	await flushAggregateMembershipDeltas(db, params.tableName, params.indexName, [delta]);
-};
-const computeCountKeyParts = (doc, fields) => fields.map((field) => normalizeUndefined(doc[field]));
-const applyAggregateIndexesForChange = async (db, tableName, aggregateIndexes, change) => {
-	const docId = String(change.id);
-	for (const aggregateIndex of aggregateIndexes) {
-		const keyParts = change.operation === "delete" ? null : computeCountKeyParts(change.newDoc, aggregateIndex.fields);
-		const metricValues = change.operation === "delete" ? null : computeAggregateMetricValues(change.newDoc, aggregateIndex);
-		await reconcileAggregateMembership(db, {
-			tableName,
-			indexName: aggregateIndex.name,
-			docId,
-			keyParts,
-			metricValues
-		});
-	}
-};
-const getCountState = async (db, tableName, indexName, kind = AGGREGATE_STATE_KIND_METRIC) => {
-	const state = (await db.query(AGGREGATE_STATE_TABLE).withIndex("by_kind_table_index", (q) => q.eq("kind", kind).eq("tableKey", tableName).eq("indexName", indexName)).collect())[0];
-	if (!state) return null;
-	const { tableKey, ...rest } = state;
-	return {
-		...rest,
-		tableName: tableKey
-	};
-};
-const assertAggregateIndexesWritable = async (db, tableName, metricIndexNames, rankIndexNames) => {
-	const clearingStates = await db.query(AGGREGATE_STATE_TABLE).withIndex("by_table_status", (q) => q.eq("tableKey", tableName).eq("status", COUNT_STATUS_CLEARING)).collect();
-	const metricNames = new Set(metricIndexNames);
-	const rankNames = new Set(rankIndexNames);
-	const blockingState = clearingStates.find((state) => state.kind === AGGREGATE_STATE_KIND_RANK ? rankNames.has(state.indexName) : metricNames.has(state.indexName));
-	if (!blockingState) return;
-	const indexType = blockingState.kind === AGGREGATE_STATE_KIND_RANK ? "rankIndex" : "aggregateIndex";
-	throw createError(blockingState.kind === AGGREGATE_STATE_KIND_RANK ? "RANK_INDEX_BUILDING" : AGGREGATE_ERROR.INDEX_BUILDING, `${indexType} '${tableName}.${blockingState.indexName}' is CLEARING. Retry the write after aggregateBackfill reaches BUILDING or READY.`);
-};
-const setCountState = async (db, nextState, kind = AGGREGATE_STATE_KIND_METRIC) => {
-	const existing = await getCountState(db, nextState.tableName, nextState.indexName, kind);
-	const payload = {
-		kind,
-		tableKey: nextState.tableName,
-		indexName: nextState.indexName,
-		keyDefinitionHash: nextState.keyDefinitionHash,
-		metricDefinitionHash: nextState.metricDefinitionHash,
-		status: nextState.status,
-		cursor: nextState.cursor ?? null,
-		processed: nextState.processed,
-		startedAt: nextState.startedAt,
-		updatedAt: nextState.updatedAt,
-		completedAt: nextState.completedAt ?? null,
-		lastError: nextState.lastError ?? null
-	};
-	if (!existing) {
-		await db.insert(AGGREGATE_STATE_TABLE, payload);
-		return;
-	}
-	await db.patch(AGGREGATE_STATE_TABLE, existing._id, payload);
-};
-const setCountStateError = async (db, tableName, indexName, error, kind = AGGREGATE_STATE_KIND_METRIC) => {
-	const now = Date.now();
-	const existing = await getCountState(db, tableName, indexName, kind);
-	const message = error instanceof Error ? error.message : String(error);
-	if (!existing) throw new Error(`Missing count state for '${tableName}.${indexName}' while recording backfill error.`);
-	await db.patch(AGGREGATE_STATE_TABLE, existing._id, {
-		status: existing.status === COUNT_STATUS_CLEARING ? COUNT_STATUS_CLEARING : COUNT_STATUS_BUILDING,
-		updatedAt: now,
-		keyDefinitionHash: existing.keyDefinitionHash,
-		metricDefinitionHash: existing.metricDefinitionHash,
-		lastError: message
-	});
-};
-/**
-* Removes at most `batchSize` documents of an aggregate index's stored state and
-* reports whether anything is left. Callers drive it to completion across
-* transactions, so clearing a large index never has to fit in one mutation.
-*
-* Members are removed through the normal delta machinery rather than raw
-* deletes, so buckets and extrema stay consistent with the members that remain
-* at every intermediate step. That keeps concurrent writers correct while the
-* clear drains. Residual bucket/extrema rows (drift with no member behind them)
-* are swept only once no members are left, and the loop re-checks members
-* afterwards.
-*/
-const clearCountIndexChunk = async (db, tableName, indexName, batchSize) => {
-	const members = await takeMembersForIndex(db, tableName, indexName, batchSize);
-	if (members.length > 0) {
-		await flushAggregateMembershipDeltas(db, tableName, indexName, members.map((member) => computeMembershipDelta(member, {
-			tableName,
-			indexName,
-			docId: member.docId,
-			keyParts: null,
-			metricValues: null
-		})));
-		return {
-			done: false,
-			processed: members.length
-		};
-	}
-	const buckets = await takeBucketsForIndex(db, tableName, indexName, batchSize);
-	if (buckets.length > 0) {
-		for (const bucket of buckets) await db.delete(AGGREGATE_BUCKET_TABLE, bucket._id);
-		return {
-			done: false,
-			processed: buckets.length
-		};
-	}
-	const extrema = await takeExtremaForIndex(db, tableName, indexName, batchSize);
-	if (extrema.length > 0) {
-		for (const entry of extrema) await db.delete(AGGREGATE_EXTREMA_TABLE, entry._id);
-		return {
-			done: false,
-			processed: extrema.length
-		};
-	}
-	return {
-		done: true,
-		processed: 0
-	};
-};
-const createCountError = (code, message) => createError(code, message);
-const createAggregateError = (code, message) => createError(code, message);
-const assertAggregateAllowedForRls = (tableConfig, rlsMode, code, methodName) => {
-	if ((typeof tableConfig.table.isRlsEnabled === "function" ? tableConfig.table.isRlsEnabled() : false) && rlsMode !== "skip") throw createError(code, `${methodName} is not available for table '${tableConfig.name}' in RLS-restricted contexts in v1.`);
-};
-const ensureCountAllowedForRls = (tableConfig, rlsMode) => {
-	assertAggregateAllowedForRls(tableConfig, rlsMode, COUNT_ERROR.RLS_UNSUPPORTED, "count()");
-};
-const ensureAggregateAllowedForRls = (tableConfig, rlsMode, methodName) => {
-	assertAggregateAllowedForRls(tableConfig, rlsMode, AGGREGATE_ERROR.RLS_UNSUPPORTED, methodName);
-};
-const ensureIndexReady = async (db, tableName, indexName, code, indexLabel) => {
-	const state = await getCountState(db, tableName, indexName);
-	if (!state || state.status !== COUNT_STATUS_READY) throw createError(code, `${indexLabel} '${tableName}.${indexName}' is BUILDING. Run aggregateBackfill until READY.`);
-};
-const ensureCountIndexReady = async (db, tableName, indexName) => ensureIndexReady(db, tableName, indexName, COUNT_ERROR.INDEX_BUILDING, "aggregateIndex");
-const ensureAggregateIndexReady = async (db, tableName, indexName) => ensureIndexReady(db, tableName, indexName, AGGREGATE_ERROR.INDEX_BUILDING, "aggregateIndex");
-const listSchemaAggregateIndexes = (schema) => {
-	const entries = [];
-	for (const tableConfig of Object.values(schema)) {
-		const aggregateIndexes = getAggregateIndexDefinitions(tableConfig);
-		for (const aggregateIndex of aggregateIndexes) entries.push({
-			tableName: tableConfig.name,
-			indexName: aggregateIndex.name,
-			fields: aggregateIndex.fields,
-			countFields: aggregateIndex.countFields,
-			sumFields: aggregateIndex.sumFields,
-			avgFields: aggregateIndex.avgFields,
-			minFields: aggregateIndex.minFields,
-			maxFields: aggregateIndex.maxFields
-		});
-	}
-	return entries;
-};
-const isIndexCountZero = (plan) => Array.isArray(plan.keyCandidates) && plan.keyCandidates.length === 0 || [...Object.values(plan.fieldValues), ...Object.values(plan.postFieldValues)].some((values) => values.length === 0);
-const isAggregatePlanZero = (plan) => Array.isArray(plan.keyCandidates) && plan.keyCandidates.length === 0 || [...Object.values(plan.fieldValues), ...Object.values(plan.postFieldValues)].some((values) => values.length === 0);
-
-//#endregion
-//#region src/orm/aggregate-index/rank-runtime.ts
-const isObject = (value) => !!value && typeof value === "object" && !Array.isArray(value);
-const stableEquals = (left, right) => JSON.stringify(left) === JSON.stringify(right);
-const RANK_MEMBER_KIND = AGGREGATE_STATE_KIND_RANK;
-const RANK_ERROR = {
-	FILTER_UNSUPPORTED: "RANK_FILTER_UNSUPPORTED",
-	NOT_INDEXED: "RANK_NOT_INDEXED",
-	INDEX_BUILDING: "RANK_INDEX_BUILDING",
-	RLS_UNSUPPORTED: "RANK_RLS_UNSUPPORTED"
-};
-const createRankError = (code, message) => /* @__PURE__ */ new Error(`${code}: ${message}`);
-const rankAggregateName = (tableName, indexName) => `${tableName}.${indexName}`;
-const rankAggregate = (tableName, indexName) => new DirectAggregate({ name: rankAggregateName(tableName, indexName) });
-const toRankValue = (value) => {
-	if (value === null || value === void 0) return null;
-	if (value instanceof Date) return value.getTime();
-	if (typeof value === "number" && Number.isFinite(value)) return value;
-	throw createRankError(RANK_ERROR.FILTER_UNSUPPORTED, `rankIndex order field values must be finite numbers or dates; received '${typeof value}'.`);
-};
-const decodeRankValue = (value, direction) => {
-	if (value === null || value === void 0) return null;
-	if (typeof value === "number") return direction === "desc" ? -value : value;
-	return value;
-};
-const getRankSortKey = (definition, doc, docId) => {
-	const key = [];
-	for (const orderField of definition.orderFields) {
-		const rawValue = toRankValue(doc[orderField.field]);
-		if (rawValue === null) {
-			key.push(null);
-			continue;
-		}
-		key.push(orderField.direction === "desc" ? -rawValue : rawValue);
-	}
-	key.push(docId);
-	return key;
-};
-const toPublicRankKey = (definition, key) => {
-	if (!Array.isArray(key)) return key;
-	const restored = key.slice(0, definition.orderFields.length).map((value, index) => decodeRankValue(value, definition.orderFields[index].direction));
-	return restored.length === 1 ? restored[0] : restored;
-};
-const getRankSumValue = (definition, doc) => {
-	if (!definition.sumField) return 1;
-	const raw = doc[definition.sumField];
-	if (raw === null || raw === void 0) return 0;
-	if (typeof raw !== "number" || !Number.isFinite(raw)) throw createRankError(RANK_ERROR.FILTER_UNSUPPORTED, `rankIndex '${definition.name}' sum field '${definition.sumField}' must be a finite number.`);
-	return raw;
-};
-const validateRankWhereValue = (value) => {
-	if (value === null || value === void 0) return null;
-	if (isObject(value)) {
-		if (Object.hasOwn(value, "eq")) return value.eq ?? null;
-		if (value.isNull === true) return null;
-		throw createRankError(RANK_ERROR.FILTER_UNSUPPORTED, "rank() where supports only eq and isNull: true on partition fields.");
-	}
-	if (Array.isArray(value)) throw createRankError(RANK_ERROR.FILTER_UNSUPPORTED, "rank() where does not support IN arrays in v1.");
-	return value;
-};
-const collectWhere = (where, fields, out) => {
-	if (Object.hasOwn(where, "OR") || Object.hasOwn(where, "NOT")) throw createRankError(RANK_ERROR.FILTER_UNSUPPORTED, "rank() where supports conjunctions only (object fields + AND).");
-	if (Object.hasOwn(where, "RAW")) throw createRankError(RANK_ERROR.FILTER_UNSUPPORTED, "rank() where does not support RAW filters.");
-	const andEntries = where.AND;
-	if (andEntries !== void 0) {
-		if (!Array.isArray(andEntries)) throw createRankError(RANK_ERROR.FILTER_UNSUPPORTED, "rank() where AND must be an array.");
-		for (const entry of andEntries) {
-			if (!isObject(entry)) throw createRankError(RANK_ERROR.FILTER_UNSUPPORTED, "rank() where AND entries must be objects.");
-			collectWhere(entry, fields, out);
-		}
-	}
-	for (const [field, rawValue] of Object.entries(where)) {
-		if (field === "AND") continue;
-		if (!fields.has(field)) throw createRankError(RANK_ERROR.FILTER_UNSUPPORTED, `rank() where field '${field}' is not a partition field.`);
-		const nextValue = validateRankWhereValue(rawValue);
-		const prevValue = out.get(field);
-		if (prevValue !== void 0 && !stableEquals(prevValue, nextValue)) throw createRankError(RANK_ERROR.FILTER_UNSUPPORTED, `rank() where has conflicting constraints for '${field}'.`);
-		out.set(field, nextValue);
-	}
-};
-const buildNamespace = (definition, values) => {
-	if (definition.partitionFields.length === 0) return;
-	const parts = definition.partitionFields.map((field) => values.get(field));
-	return parts.length === 1 ? parts[0] : parts;
-};
-const getRankIndexDefinitions = (tableConfig) => {
-	const rankIndexes = tableConfig.table.getRankIndexes?.();
-	if (!Array.isArray(rankIndexes)) return [];
-	return rankIndexes.map((entry) => ({
-		name: entry.name,
-		partitionFields: entry.partitionFields ?? [],
-		orderFields: entry.orderFields ?? [],
-		sumField: entry.sumField
-	}));
-};
-const ensureRankAllowedForRls = (tableConfig, rlsMode) => {
-	if ((typeof tableConfig.table.isRlsEnabled === "function" ? tableConfig.table.isRlsEnabled() : false) && rlsMode !== "skip") throw createRankError(RANK_ERROR.RLS_UNSUPPORTED, `rank() is not available for table '${tableConfig.name}' in RLS-restricted contexts in v1.`);
-};
-const compileRankPlan = (tableConfig, indexName, where) => {
-	const definition = getRankIndexDefinitions(tableConfig).find((entry) => entry.name === indexName);
-	if (!definition) throw createRankError(RANK_ERROR.NOT_INDEXED, `No rankIndex '${indexName}' found on '${tableConfig.name}'. Declare rankIndex('${indexName}') and run aggregateBackfill.`);
-	if (!isObject(where ?? {})) throw createRankError(RANK_ERROR.FILTER_UNSUPPORTED, "rank() where must be an object filter.");
-	const values = /* @__PURE__ */ new Map();
-	collectWhere(where ?? {}, new Set(definition.partitionFields), values);
-	for (const field of definition.partitionFields) if (!values.has(field)) throw createRankError(RANK_ERROR.NOT_INDEXED, `rank() on '${tableConfig.name}.${indexName}' requires all partition fields constrained: [${definition.partitionFields.join(", ")}].`);
-	return {
-		tableName: tableConfig.name,
-		indexName,
-		definition,
-		namespace: buildNamespace(definition, values)
-	};
-};
-const ensureRankIndexReady = async (db, tableName, indexName) => {
-	const state = await getCountState(db, tableName, indexName, AGGREGATE_STATE_KIND_RANK);
-	if (!state || state.status !== COUNT_STATUS_READY) throw createRankError(RANK_ERROR.INDEX_BUILDING, `rankIndex '${tableName}.${indexName}' is BUILDING. Run aggregateBackfill until READY.`);
-};
-const getRankMemberByDoc = async (db, tableName, indexName, docId) => {
-	return (await db.query(AGGREGATE_MEMBER_TABLE).withIndex("by_kind_table_index_doc", (q) => q.eq("kind", RANK_MEMBER_KIND).eq("tableKey", tableName).eq("indexName", indexName).eq("docId", docId)).collect())[0] ?? null;
-};
-const takeRankMembers = async (db, tableName, indexName, limit) => await db.query(AGGREGATE_MEMBER_TABLE).withIndex("by_kind_table_index", (q) => q.eq("kind", RANK_MEMBER_KIND).eq("tableKey", tableName).eq("indexName", indexName)).take(limit);
-const rankCtx = (db) => ({
-	db,
-	orm: void 0
-});
-/** Trees dropped per invocation once every rank member has been removed. */
-const RANK_TREE_DROP_BATCH = 16;
-/**
-* Removes at most `batchSize` rank members and reports whether anything is
-* left. Each member is removed from the btree before its row is dropped, so the
-* tree stays consistent with the members that remain and a partially drained
-* clear can safely resume in a later mutation.
-*/
-const clearRankIndexChunk = async (db, tableName, indexName, batchSize) => {
-	const aggregate = rankAggregate(tableName, indexName);
-	const ctx = rankCtx(db);
-	const members = await takeRankMembers(db, tableName, indexName, batchSize);
-	if (members.length > 0) {
-		for (const member of members) {
-			if (member.rankKey !== void 0) await aggregate.deleteIfExists(ctx, {
-				id: member.docId,
-				key: member.rankKey,
-				namespace: member.rankNamespace
-			});
-			await db.delete(AGGREGATE_MEMBER_TABLE, member._id);
-		}
-		return {
-			done: false,
-			processed: members.length
+		this.config = {
+			name,
+			expression
 		};
 	}
-	const done = await aggregate.deleteTrees(ctx, RANK_TREE_DROP_BATCH);
-	return {
-		done,
-		processed: done ? 0 : RANK_TREE_DROP_BATCH
-	};
-};
-const reconcileRankMembership = async (db, params) => {
-	const { tableName, definition, docId, doc } = params;
-	const existing = await getRankMemberByDoc(db, tableName, definition.name, docId);
-	const aggregate = rankAggregate(tableName, definition.name);
-	const ctx = rankCtx(db);
-	const now = Date.now();
-	if (!doc) {
-		if (existing?.rankKey !== void 0) {
-			await aggregate.delete(ctx, {
-				id: docId,
-				key: existing.rankKey,
-				namespace: existing.rankNamespace
-			});
-			await db.delete(AGGREGATE_MEMBER_TABLE, existing._id);
-		}
-		return;
-	}
-	const namespace = buildNamespace(definition, new Map(definition.partitionFields.map((field) => [field, doc[field]])));
-	const key = getRankSortKey(definition, doc, docId);
-	const sumValue = getRankSumValue(definition, doc);
-	if (existing && stableEquals(existing.rankNamespace, namespace) && stableEquals(existing.rankKey, key) && (existing.rankSumValue ?? 0) === sumValue) return;
-	if (existing?.rankKey !== void 0) {
-		await aggregate.replace(ctx, {
-			id: docId,
-			key: existing.rankKey,
-			namespace: existing.rankNamespace
-		}, {
-			key,
-			namespace,
-			sumValue
-		});
-		await db.patch(AGGREGATE_MEMBER_TABLE, existing._id, {
-			kind: RANK_MEMBER_KIND,
-			keyHash: "__rank__",
-			keyParts: [],
-			sumValues: {},
-			nonNullCountValues: {},
-			extremaValues: {},
-			rankNamespace: namespace,
-			rankKey: key,
-			rankSumValue: sumValue,
-			updatedAt: now
-		});
-		return;
-	}
-	await aggregate.insert(ctx, {
-		id: docId,
-		key,
-		namespace,
-		sumValue
-	});
-	await db.insert(AGGREGATE_MEMBER_TABLE, {
-		kind: RANK_MEMBER_KIND,
-		tableKey: tableName,
-		indexName: definition.name,
-		docId,
-		keyHash: "__rank__",
-		keyParts: [],
-		sumValues: {},
-		nonNullCountValues: {},
-		extremaValues: {},
-		rankNamespace: namespace,
-		rankKey: key,
-		rankSumValue: sumValue,
-		updatedAt: now
-	});
-};
-const applyRankIndexesForChange = async (db, tableName, rankIndexes, change) => {
-	const docId = String(change.id);
-	for (const rankIndex of rankIndexes) await reconcileRankMembership(db, {
-		tableName,
-		definition: rankIndex,
-		docId,
-		doc: change.operation === "delete" ? null : change.newDoc
-	});
-};
-const readRankCount = async (db, plan) => {
-	return await rankAggregate(plan.tableName, plan.indexName).count(rankCtx(db), { namespace: plan.namespace });
-};
-const readRankSum = async (db, plan) => {
-	return await rankAggregate(plan.tableName, plan.indexName).sum(rankCtx(db), { namespace: plan.namespace });
-};
-const toPublicRankItem = (plan, item) => ({
-	id: item.id,
-	key: toPublicRankKey(plan.definition, item.key),
-	sumValue: item.sumValue
-});
-const readRankAtWithCount = async (db, plan, offset, count) => {
-	if (count <= 0) return null;
-	const normalizedOffset = offset < 0 ? count + offset : offset;
-	if (normalizedOffset < 0 || normalizedOffset >= count) return null;
-	return toPublicRankItem(plan, await rankAggregate(plan.tableName, plan.indexName).at(rankCtx(db), offset, { namespace: plan.namespace }));
-};
-const readRankAt = async (db, plan, offset) => await readRankAtWithCount(db, plan, offset, await readRankCount(db, plan));
-const readRankIndexOf = async (db, plan, args) => {
-	const member = await getRankMemberByDoc(db, plan.tableName, plan.indexName, args.id);
-	if (!member || member.rankKey === void 0) return -1;
-	if (!stableEquals(member.rankNamespace, plan.namespace)) return -1;
-	return await rankAggregate(plan.tableName, plan.indexName).indexOf(rankCtx(db), member.rankKey, {
-		namespace: plan.namespace,
-		id: args.id
-	});
-};
-const readRankPaginate = async (db, plan, cursor, limit) => {
-	const paged = await rankAggregate(plan.tableName, plan.indexName).paginate(rankCtx(db), {
-		namespace: plan.namespace,
-		cursor: cursor ?? void 0,
-		pageSize: limit
-	});
-	return {
-		continueCursor: paged.cursor ?? "",
-		isDone: paged.isDone,
-		page: paged.page.map((item) => toPublicRankItem(plan, item))
-	};
-};
-const readRankMin = async (db, plan) => {
-	const item = await rankAggregate(plan.tableName, plan.indexName).min(rankCtx(db), { namespace: plan.namespace });
-	return item ? toPublicRankItem(plan, item) : null;
-};
-const readRankMax = async (db, plan) => {
-	const item = await rankAggregate(plan.tableName, plan.indexName).max(rankCtx(db), { namespace: plan.namespace });
-	return item ? toPublicRankItem(plan, item) : null;
-};
-const readRankRandom = async (db, plan) => {
-	const count = await readRankCount(db, plan);
-	if (count <= 0) return null;
-	return await readRankAtWithCount(db, plan, Math.floor(Math.random() * count), count);
 };
+function check(name, expression) {
+	return new ConvexCheckBuilder(name, expression);
+}
 
 //#endregion
-//#region src/orm/aggregate-index/backfill.ts
-const DEFAULT_BACKFILL_BATCH_SIZE = 1e3;
-const getBackfillMode = (candidate) => {
-	if (candidate === void 0) return "resume";
-	if (candidate === "resume" || candidate === "rebuild" || candidate === "prune") return candidate;
-	throw new Error("countBackfill mode must be one of 'resume', 'rebuild', or 'prune'.");
-};
-const getBackfillBatchSize = (candidate) => {
-	if (candidate === void 0) return DEFAULT_BACKFILL_BATCH_SIZE;
-	if (typeof candidate !== "number" || !Number.isInteger(candidate)) throw new Error("countBackfill batchSize must be a positive integer.");
-	if (candidate < 1) throw new Error("countBackfill batchSize must be a positive integer.");
-	return candidate;
-};
-const matchesFilter = (target, args) => {
-	if (args.tableName && target.tableName !== args.tableName) return false;
-	if (args.indexName && target.indexName !== args.indexName) return false;
-	return true;
-};
-const getTargets = (schema, args) => {
-	const metricTargets = listSchemaAggregateIndexes(schema).map((entry) => ({
-		kind: "metric",
-		tableName: entry.tableName,
-		indexName: entry.indexName,
-		fields: entry.fields,
-		countFields: entry.countFields,
-		sumFields: entry.sumFields,
-		avgFields: entry.avgFields,
-		minFields: entry.minFields,
-		maxFields: entry.maxFields
-	}));
-	const rankTargets = [];
-	for (const tableConfig of Object.values(schema)) {
-		const rankIndexes = getRankIndexDefinitions(tableConfig);
-		for (const rankIndex of rankIndexes) rankTargets.push({
-			kind: "rank",
-			tableName: tableConfig.name,
-			indexName: rankIndex.name,
-			fields: rankIndex.partitionFields,
-			orderFields: rankIndex.orderFields,
-			rankSumField: rankIndex.sumField
-		});
+//#region src/orm/capabilities.ts
+const resolveOrmCapabilities = (capabilities) => {
+	const resolved = {};
+	for (const capability of capabilities ?? []) {
+		if (capability.kind === "aggregate") {
+			resolved.aggregate = capability.value;
+			continue;
+		}
+		resolved.migrations = capability.value;
 	}
-	return [...metricTargets, ...rankTargets].filter((entry) => matchesFilter(entry, args));
+	return resolved;
 };
-const dedupe = (fields) => [...new Set(fields)];
-const computeMetricDefinition = (target) => ({
-	countFields: dedupe(target.countFields ?? []),
-	sumFields: dedupe(target.sumFields ?? []),
-	avgFields: dedupe(target.avgFields ?? []),
-	minFields: dedupe(target.minFields ?? []),
-	maxFields: dedupe(target.maxFields ?? [])
-});
-const computeKeyDefinitionHash = (target) => JSON.stringify({
-	kind: target.kind,
-	fields: target.fields,
-	orderFields: target.orderFields ?? []
-});
-const computeMetricDefinitionHash = (target) => target.kind === "rank" ? JSON.stringify({ sumField: target.rankSumField ?? null }) : JSON.stringify(computeMetricDefinition(target));
-const parseMetricDefinitionHash = (metricDefinitionHash) => {
-	let parsed;
-	try {
-		parsed = JSON.parse(metricDefinitionHash);
-	} catch {
-		throw new Error(`Invalid metricDefinitionHash payload: ${metricDefinitionHash}`);
-	}
-	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("Invalid metricDefinitionHash payload shape.");
-	const pick = (key) => {
-		const candidate = parsed[key];
-		if (!Array.isArray(candidate)) throw new Error(`metricDefinitionHash is missing '${key}'.`);
-		if (candidate.some((entry) => typeof entry !== "string")) throw new Error(`metricDefinitionHash has non-string value in '${key}'.`);
-		return dedupe(candidate);
-	};
-	return {
-		countFields: pick("countFields"),
-		sumFields: pick("sumFields"),
-		avgFields: pick("avgFields"),
-		minFields: pick("minFields"),
-		maxFields: pick("maxFields")
-	};
+const AGGREGATE_SETUP_HINT = "Generated ORM: declare an aggregateIndex(...)/rankIndex(...) in your schema and rerun `kitcn codegen`, which registers the capability in <functionsDir>/generated/server.ts. Hand-written ORM: import { aggregateCapability } from 'kitcn/orm/aggregate-index' and pass createOrm({ schema, capabilities: [aggregateCapability()] }).";
+const missingAggregateCapabilityError = (usage) => /* @__PURE__ */ new Error(`${usage} requires the aggregate capability. ${AGGREGATE_SETUP_HINT}`);
+const requireAggregateCapability = (capabilities, usage) => {
+	const aggregate = capabilities?.aggregate;
+	if (!aggregate) throw missingAggregateCapabilityError(usage);
+	return aggregate;
 };
-const toMetricStorageDefinition = (metricDefinition) => ({
-	sumFields: new Set([...metricDefinition.sumFields, ...metricDefinition.avgFields]),
-	nonNullCountFields: new Set([...metricDefinition.countFields, ...metricDefinition.avgFields]),
-	extremaFields: new Set([...metricDefinition.minFields, ...metricDefinition.maxFields])
-});
-const requiresMetricBackfill = (existingMetricDefinitionHash, targetMetricDefinitionHash) => {
-	const existingDefinition = parseMetricDefinitionHash(existingMetricDefinitionHash);
-	const targetDefinition = parseMetricDefinitionHash(targetMetricDefinitionHash);
-	const existingStorage = toMetricStorageDefinition(existingDefinition);
-	const targetStorage = toMetricStorageDefinition(targetDefinition);
-	const hasMissing = (target, existing) => {
-		for (const field of target) if (!existing.has(field)) return true;
-		return false;
-	};
-	return hasMissing(targetStorage.sumFields, existingStorage.sumFields) || hasMissing(targetStorage.nonNullCountFields, existingStorage.nonNullCountFields) || hasMissing(targetStorage.extremaFields, existingStorage.extremaFields);
+const requireMigrationCapability = (capabilities, usage) => {
+	const migrations = capabilities?.migrations;
+	if (!migrations) throw new Error(`${usage} requires the migration capability. Generated ORM: add a migration under <functionsDir>/migrations and rerun \`kitcn codegen\`, which registers the capability in <functionsDir>/generated/server.ts. Hand-written ORM: import { migrationCapability } from 'kitcn/orm/migrations' and pass createOrm({ schema, capabilities: [migrationCapability()] }).`);
+	return migrations;
 };
-function createCountBackfillHandlers(schema, getChunkRef) {
-	const serializeKey = (kind, tableName, indexName) => `${kind}\u0000${tableName}\u0000${indexName}`;
-	const stateKindFor = (kind) => kind === "rank" ? AGGREGATE_STATE_KIND_RANK : AGGREGATE_STATE_KIND_METRIC;
-	const scheduleChunk = async (ctx, tableName, indexName, batchSize) => {
-		const chunkRef = getChunkRef?.();
-		if (ctx.scheduler && chunkRef) await ctx.scheduler.runAfter(0, chunkRef, {
-			tableName,
-			indexName,
-			batchSize
-		});
-	};
-	/**
-	* Drains an index's stored state until it is empty or the shared per-mutation
-	* budget runs out. Returns true only when the index is fully cleared, so the
-	* caller knows whether to advance the state machine or reschedule.
-	*/
-	const drainIndexClear = async (ctx, kind, tableName, indexName, batchSize, budget) => {
-		while (budget.remaining > 0) {
-			const limit = Math.min(batchSize, budget.remaining);
-			const step = kind === "rank" ? await clearRankIndexChunk(ctx.db, tableName, indexName, limit) : await clearCountIndexChunk(ctx.db, tableName, indexName, limit);
-			if (step.done) return true;
-			budget.remaining -= Math.max(step.processed, 1);
-		}
-		return false;
-	};
-	const pruneRemovedState = async (ctx, args, targets, batchSize, clearBudget) => {
-		const targetKeys = new Set(targets.map((target) => serializeKey(target.kind, target.tableName, target.indexName)));
-		const states = await ctx.db.query(AGGREGATE_STATE_TABLE).collect();
-		const stateByKey = new Map(states.map((state) => [serializeKey(state.kind === AGGREGATE_STATE_KIND_RANK ? "rank" : "metric", state.tableKey, state.indexName), state]));
-		const existingKeys = /* @__PURE__ */ new Set();
-		for (const state of states) existingKeys.add(serializeKey(state.kind === AGGREGATE_STATE_KIND_RANK ? "rank" : "metric", state.tableKey, state.indexName));
-		if (args.tableName && args.indexName) {
-			const tableName = args.tableName;
-			const indexName = args.indexName;
-			const [bucket, extrema, metricMember, rankMember] = await Promise.all([
-				ctx.db.query(AGGREGATE_BUCKET_TABLE).withIndex("by_table_index", (q) => q.eq("tableKey", tableName).eq("indexName", indexName)).first(),
-				ctx.db.query(AGGREGATE_EXTREMA_TABLE).withIndex("by_table_index", (q) => q.eq("tableKey", tableName).eq("indexName", indexName)).first(),
-				ctx.db.query(AGGREGATE_MEMBER_TABLE).withIndex("by_kind_table_index", (q) => q.eq("kind", AGGREGATE_STATE_KIND_METRIC).eq("tableKey", tableName).eq("indexName", indexName)).first(),
-				ctx.db.query(AGGREGATE_MEMBER_TABLE).withIndex("by_kind_table_index", (q) => q.eq("kind", AGGREGATE_STATE_KIND_RANK).eq("tableKey", tableName).eq("indexName", indexName)).first()
-			]);
-			if (bucket || extrema || metricMember) existingKeys.add(serializeKey("metric", tableName, indexName));
-			if (rankMember) existingKeys.add(serializeKey("rank", tableName, indexName));
-		}
-		let pruned = 0;
-		let pruning = 0;
-		for (const key of existingKeys) {
-			const [kind, tableName, indexName] = key.split("\0");
-			if (args.tableName && tableName !== args.tableName) continue;
-			if (args.indexName && indexName !== args.indexName) continue;
-			if (targetKeys.has(key)) continue;
-			const state = stateByKey.get(key);
-			if (!await drainIndexClear(ctx, kind, tableName, indexName, batchSize, clearBudget)) {
-				const now = Date.now();
-				await setCountState(ctx.db, {
-					tableName,
-					indexName,
-					kind: stateKindFor(kind),
-					keyDefinitionHash: state?.keyDefinitionHash ?? "",
-					metricDefinitionHash: state?.metricDefinitionHash ?? "",
-					status: COUNT_STATUS_CLEARING,
-					cursor: null,
-					processed: 0,
-					startedAt: now,
-					updatedAt: now,
-					completedAt: null,
-					lastError: null
-				}, stateKindFor(kind));
-				await scheduleChunk(ctx, tableName, indexName, batchSize);
-				pruning += 1;
-				continue;
-			}
-			if (state) await ctx.db.delete(AGGREGATE_STATE_TABLE, state._id);
-			pruned += 1;
-		}
-		return {
-			pruned,
-			pruning
-		};
-	};
-	/**
-	* Finishes clearing an index that no longer exists in the schema. Orphans have
-	* no backfill target, so they are driven purely by their CLEARING state row.
-	* Returns true when this invocation handled one.
-	*/
-	const drainOrphanClear = async (ctx, args, targets, batchSize) => {
-		const targetKeys = new Set(targets.map((target) => serializeKey(target.kind, target.tableName, target.indexName)));
-		const states = await ctx.db.query(AGGREGATE_STATE_TABLE).collect();
-		for (const state of states) {
-			if (state.status !== COUNT_STATUS_CLEARING) continue;
-			const kind = state.kind === AGGREGATE_STATE_KIND_RANK ? "rank" : "metric";
-			if (targetKeys.has(serializeKey(kind, state.tableKey, state.indexName))) continue;
-			if (args.tableName && state.tableKey !== args.tableName) continue;
-			if (args.indexName && state.indexName !== args.indexName) continue;
-			if (await drainIndexClear(ctx, kind, state.tableKey, state.indexName, batchSize, { remaining: batchSize })) {
-				await ctx.db.delete(AGGREGATE_STATE_TABLE, state._id);
-				return true;
-			}
-			await ctx.db.patch(AGGREGATE_STATE_TABLE, state._id, { updatedAt: Date.now() });
-			await scheduleChunk(ctx, state.tableKey, state.indexName, batchSize);
-			return true;
-		}
-		return false;
-	};
-	const kickoff = async (ctx, args) => {
-		const targets = getTargets(schema, args);
-		const mode = getBackfillMode(args.mode);
-		const batchSize = getBackfillBatchSize(args.batchSize);
-		const clearBudget = { remaining: batchSize };
-		const { pruned, pruning } = await pruneRemovedState(ctx, args, targets, batchSize, clearBudget);
-		if (mode === "prune") return {
-			targets: targets.length,
-			mode,
-			scheduled: 0,
-			skippedReady: 0,
-			needsRebuild: 0,
-			pruned,
-			pruning,
-			status: "ok"
-		};
-		const now = Date.now();
-		let scheduled = 0;
-		let skippedReady = 0;
-		let needsRebuild = 0;
-		for (const target of targets) {
-			const stateKind = target.kind === "rank" ? AGGREGATE_STATE_KIND_RANK : AGGREGATE_STATE_KIND_METRIC;
-			const existing = await getCountState(ctx.db, target.tableName, target.indexName, stateKind);
-			const keyDefinitionHash = computeKeyDefinitionHash(target);
-			const metricDefinitionHash = computeMetricDefinitionHash(target);
-			const nextStateBase = {
-				tableName: target.tableName,
-				indexName: target.indexName,
-				keyDefinitionHash,
-				metricDefinitionHash
-			};
-			if (mode === "rebuild") {
-				const cleared = await drainIndexClear(ctx, target.kind, target.tableName, target.indexName, batchSize, clearBudget);
-				await setCountState(ctx.db, {
-					...nextStateBase,
-					kind: stateKind,
-					status: cleared ? COUNT_STATUS_BUILDING : COUNT_STATUS_CLEARING,
-					cursor: null,
-					processed: 0,
-					startedAt: now,
-					updatedAt: now,
-					completedAt: null,
-					lastError: null
-				}, stateKind);
-			} else if (existing) {
-				if (existing.keyDefinitionHash !== keyDefinitionHash) {
-					needsRebuild += 1;
-					continue;
-				}
-				if (existing.metricDefinitionHash !== metricDefinitionHash) {
-					if (!(target.kind === "rank" ? true : requiresMetricBackfill(existing.metricDefinitionHash, metricDefinitionHash)) && existing.status === COUNT_STATUS_READY) {
-						await setCountState(ctx.db, {
-							...nextStateBase,
-							kind: stateKind,
-							status: COUNT_STATUS_READY,
-							cursor: null,
-							processed: existing.processed,
-							startedAt: existing.startedAt,
-							updatedAt: now,
-							completedAt: existing.completedAt ?? now,
-							lastError: null
-						}, stateKind);
-						skippedReady += 1;
-						continue;
-					}
-					await setCountState(ctx.db, {
-						...nextStateBase,
-						kind: stateKind,
-						status: COUNT_STATUS_BUILDING,
-						cursor: null,
-						processed: 0,
-						startedAt: now,
-						updatedAt: now,
-						completedAt: null,
-						lastError: null
-					}, stateKind);
-				} else if (existing.status === COUNT_STATUS_READY) {
-					skippedReady += 1;
-					continue;
-				}
-			} else await setCountState(ctx.db, {
-				...nextStateBase,
-				kind: stateKind,
-				status: COUNT_STATUS_BUILDING,
-				cursor: null,
-				processed: 0,
-				startedAt: now,
-				updatedAt: now,
-				completedAt: null,
-				lastError: null
-			}, stateKind);
-			await scheduleChunk(ctx, target.tableName, target.indexName, batchSize);
-			scheduled += 1;
-		}
-		return {
-			targets: targets.length,
-			mode,
-			scheduled,
-			skippedReady,
-			needsRebuild,
-			pruned,
-			pruning,
-			status: "ok"
-		};
-	};
-	const chunk = async (ctx, args) => {
-		const batchSize = getBackfillBatchSize(args.batchSize);
-		const targets = getTargets(schema, args);
-		if (!(Boolean(args.tableName && args.indexName) && targets.length === 1) && await drainOrphanClear(ctx, args, targets, batchSize)) return { status: "ok" };
-		if (targets.length > 1) {
-			for (const target of targets) {
-				const stateKind = target.kind === "rank" ? AGGREGATE_STATE_KIND_RANK : AGGREGATE_STATE_KIND_METRIC;
-				const state = await getCountState(ctx.db, target.tableName, target.indexName, stateKind);
-				if (!state || state.status !== COUNT_STATUS_READY) return chunk(ctx, {
-					tableName: target.tableName,
-					indexName: target.indexName,
-					batchSize
-				});
-			}
-			return { status: "ok" };
-		}
-		for (const target of targets) {
-			const stateKind = target.kind === "rank" ? AGGREGATE_STATE_KIND_RANK : AGGREGATE_STATE_KIND_METRIC;
-			try {
-				const state = await getCountState(ctx.db, target.tableName, target.indexName, stateKind);
-				if (!state || state.status === COUNT_STATUS_READY) continue;
-				if (state.status === COUNT_STATUS_CLEARING) {
-					const cleared = await drainIndexClear(ctx, target.kind, target.tableName, target.indexName, batchSize, { remaining: batchSize });
-					const clearedAt = Date.now();
-					await setCountState(ctx.db, {
-						tableName: target.tableName,
-						indexName: target.indexName,
-						kind: stateKind,
-						keyDefinitionHash: state.keyDefinitionHash,
-						metricDefinitionHash: state.metricDefinitionHash,
-						status: cleared ? COUNT_STATUS_BUILDING : COUNT_STATUS_CLEARING,
-						cursor: null,
-						processed: 0,
-						startedAt: state.startedAt,
-						updatedAt: clearedAt,
-						completedAt: null,
-						lastError: null
-					}, stateKind);
-					await scheduleChunk(ctx, target.tableName, target.indexName, batchSize);
-					continue;
-				}
-				const cursor = state.cursor ?? null;
-				const page = await ctx.db.query(target.tableName).withIndex("by_creation_time").paginate({
-					cursor,
-					numItems: batchSize
-				});
-				const pendingDeltas = [];
-				for (const doc of page.page) if (target.kind === "rank") await reconcileRankMembership(ctx.db, {
-					tableName: target.tableName,
-					definition: {
-						name: target.indexName,
-						partitionFields: target.fields,
-						orderFields: target.orderFields ?? [],
-						sumField: target.rankSumField
-					},
-					docId: String(doc._id),
-					doc
-				});
-				else pendingDeltas.push(await computeAggregateMembershipDelta(ctx.db, {
-					tableName: target.tableName,
-					indexName: target.indexName,
-					docId: String(doc._id),
-					keyParts: computeCountKeyParts(doc, target.fields),
-					metricValues: computeAggregateMetricValues(doc, {
-						name: target.indexName,
-						fields: target.fields,
-						countFields: target.countFields ?? [],
-						sumFields: target.sumFields ?? [],
-						avgFields: target.avgFields ?? [],
-						minFields: target.minFields ?? [],
-						maxFields: target.maxFields ?? []
-					})
-				}));
-				if (pendingDeltas.length > 0) await flushAggregateMembershipDeltas(ctx.db, target.tableName, target.indexName, pendingDeltas);
-				const now = Date.now();
-				const nextProcessed = state.processed + page.page.length;
-				if (page.isDone) {
-					await setCountState(ctx.db, {
-						tableName: target.tableName,
-						indexName: target.indexName,
-						kind: stateKind,
-						keyDefinitionHash: state.keyDefinitionHash,
-						metricDefinitionHash: state.metricDefinitionHash,
-						status: COUNT_STATUS_READY,
-						cursor: null,
-						processed: nextProcessed,
-						startedAt: state.startedAt,
-						updatedAt: now,
-						completedAt: now,
-						lastError: null
-					}, stateKind);
-					continue;
-				}
-				await setCountState(ctx.db, {
-					tableName: target.tableName,
-					indexName: target.indexName,
-					kind: stateKind,
-					keyDefinitionHash: state.keyDefinitionHash,
-					metricDefinitionHash: state.metricDefinitionHash,
-					status: COUNT_STATUS_BUILDING,
-					cursor: page.continueCursor,
-					processed: nextProcessed,
-					startedAt: state.startedAt,
-					updatedAt: now,
-					completedAt: null,
-					lastError: null
-				}, stateKind);
-				await scheduleChunk(ctx, target.tableName, target.indexName, batchSize);
-			} catch (error) {
-				await setCountStateError(ctx.db, target.tableName, target.indexName, error, stateKind);
-				throw error;
-			}
-		}
-		return { status: "ok" };
-	};
-	const status = async (ctx, args) => {
-		const states = await ctx.db.query(AGGREGATE_STATE_TABLE).collect();
-		const statesByKey = new Map(states.map((entry) => [`${entry.kind === AGGREGATE_STATE_KIND_RANK ? "rank" : "metric"}:${entry.tableKey}:${entry.indexName}`, entry]));
-		return getTargets(schema, args).map((target) => {
-			const key = `${target.kind}:${target.tableName}:${target.indexName}`;
-			const entry = statesByKey.get(key);
-			if (!entry) return {
-				kind: target.kind === "rank" ? AGGREGATE_STATE_KIND_RANK : AGGREGATE_STATE_KIND_METRIC,
-				tableName: target.tableName,
-				indexName: target.indexName,
-				keyDefinitionHash: computeKeyDefinitionHash(target),
-				metricDefinitionHash: computeMetricDefinitionHash(target),
-				status: COUNT_STATUS_BUILDING,
-				cursor: null,
-				processed: 0,
-				startedAt: 0,
-				updatedAt: 0,
-				completedAt: null,
-				lastError: null
-			};
-			const { tableKey, ...rest } = entry;
-			return {
-				...rest,
-				tableName: tableKey
-			};
-		});
-	};
-	return {
-		kickoff,
-		chunk,
-		status
-	};
-}
 
 //#endregion
 //#region src/orm/query-promise.ts
@@ -4977,43 +1444,47 @@ var GelRankQuery = class {
 		this.rls = rls;
 	}
 	async _plan() {
-		ensureRankAllowedForRls(this.tableConfig, this.rls?.mode);
-		const plan = compileRankPlan(this.tableConfig, this.indexName, this.config.where);
-		await ensureRankIndexReady(this.db, this.tableConfig.name, this.indexName);
-		return plan;
+		const aggregate = requireAggregateCapability(getOrmContext(this.db)?.capabilities, "rank()");
+		aggregate.ensureRankAllowedForRls(this.tableConfig, this.rls?.mode);
+		const plan = aggregate.compileRankPlan(this.tableConfig, this.indexName, this.config.where);
+		await aggregate.ensureRankIndexReady(this.db, this.tableConfig.name, this.indexName);
+		return {
+			aggregate,
+			plan
+		};
 	}
 	async count() {
-		const plan = await this._plan();
-		return await readRankCount(this.db, plan);
+		const { aggregate, plan } = await this._plan();
+		return await aggregate.readRankCount(this.db, plan);
 	}
 	async sum() {
-		const plan = await this._plan();
-		return await readRankSum(this.db, plan);
+		const { aggregate, plan } = await this._plan();
+		return await aggregate.readRankSum(this.db, plan);
 	}
 	async at(offset) {
-		const plan = await this._plan();
-		return await readRankAt(this.db, plan, offset);
+		const { aggregate, plan } = await this._plan();
+		return await aggregate.readRankAt(this.db, plan, offset);
 	}
 	async indexOf(args) {
-		const plan = await this._plan();
-		return await readRankIndexOf(this.db, plan, args);
+		const { aggregate, plan } = await this._plan();
+		return await aggregate.readRankIndexOf(this.db, plan, args);
 	}
 	async paginate(args) {
 		if (!Number.isInteger(args.limit) || args.limit < 1) throw new Error("rank().paginate() requires a positive integer limit.");
-		const plan = await this._plan();
-		return await readRankPaginate(this.db, plan, args.cursor ?? null, args.limit);
+		const { aggregate, plan } = await this._plan();
+		return await aggregate.readRankPaginate(this.db, plan, args.cursor ?? null, args.limit);
 	}
 	async min() {
-		const plan = await this._plan();
-		return await readRankMin(this.db, plan);
+		const { aggregate, plan } = await this._plan();
+		return await aggregate.readRankMin(this.db, plan);
 	}
 	async max() {
-		const plan = await this._plan();
-		return await readRankMax(this.db, plan);
+		const { aggregate, plan } = await this._plan();
+		return await aggregate.readRankMax(this.db, plan);
 	}
 	async random() {
-		const plan = await this._plan();
-		return await readRankRandom(this.db, plan);
+		const { aggregate, plan } = await this._plan();
+		return await aggregate.readRankRandom(this.db, plan);
 	}
 };
 const CONFIGURED_INDEX_RANGE_OPERATORS = new Set([
@@ -5096,6 +1567,16 @@ var GelRelationalQuery = class GelRelationalQuery extends QueryPromise {
 		this.allowFullScan = config.allowFullScan === true;
 		this._countIndexReadinessByKey = countIndexReadiness ?? /* @__PURE__ */ new Map();
 	}
+	/**
+	* The aggregate-index runtime, registered at `createOrm()`.
+	*
+	* Only `count()`, `aggregate()` and relation counts reach this; plain reads
+	* never touch the aggregate runtime, which is why it is injected rather than
+	* statically imported.
+	*/
+	_aggregate(usage) {
+		return requireAggregateCapability(getOrmContext(this.db)?.capabilities, usage);
+	}
 	_usesSystemCreatedAtAlias(tableConfig = this.tableConfig) {
 		return usesSystemCreatedAtAlias(tableConfig.table);
 	}
@@ -6451,7 +2932,7 @@ var GelRelationalQuery = class GelRelationalQuery extends QueryPromise {
 			await existing;
 			return;
 		}
-		const pending = ensureCountIndexReady(this.db, tableName, indexName).catch((error) => {
+		const pending = this._aggregate("count()").ensureCountIndexReady(this.db, tableName, indexName).catch((error) => {
 			this._countIndexReadinessByKey.delete(key);
 			throw error;
 		});
@@ -6465,7 +2946,7 @@ var GelRelationalQuery = class GelRelationalQuery extends QueryPromise {
 			await existing;
 			return;
 		}
-		const pending = ensureAggregateIndexReady(this.db, tableName, indexName).catch((error) => {
+		const pending = this._aggregate("aggregate()").ensureAggregateIndexReady(this.db, tableName, indexName).catch((error) => {
 			this._aggregateIndexReadinessByKey.delete(key);
 			throw error;
 		});
@@ -6491,10 +2972,11 @@ var GelRelationalQuery = class GelRelationalQuery extends QueryPromise {
 			if (nativeCount !== null) return nativeCount;
 			throw createCountError(COUNT_ERROR.FILTER_UNSUPPORTED, `Native count() syscall unavailable for '${this.tableConfig.name}'.`);
 		}
-		const plan = compileCountQueryPlan(this.tableConfig, where);
-		if (isIndexCountZero(plan)) return 0;
+		const aggregate = this._aggregate("A filtered count()");
+		const plan = aggregate.compileCountQueryPlan(this.tableConfig, where);
+		if (aggregate.isIndexCountZero(plan)) return 0;
 		await this._ensureCountIndexReadyOnce(plan.tableName, plan.indexName);
-		return await readCountFromBuckets(this.db, plan, bucketCache);
+		return await aggregate.readCountFromBuckets(this.db, plan, bucketCache);
 	}
 	async _executeCount(config) {
 		const windowConfig = this._coerceCountWindowConfig(config);
@@ -6510,11 +2992,13 @@ var GelRelationalQuery = class GelRelationalQuery extends QueryPromise {
 			result._all = this._applyCountWindowBounds(total, windowConfig);
 		}
 		if (windowConfig.hasWindowBounds && select.fields.length > 0) throw createCountError(COUNT_ERROR.FILTER_UNSUPPORTED, "count({ select: { field: true } }) does not support skip/take/cursor in v1. Use count() or count({ select: { _all: true } }).");
+		if (select.fields.length === 0) return result;
+		const aggregate = this._aggregate("count({ select: { field: true } })");
 		const fieldEntries = await Promise.all(select.fields.map(async (field) => {
-			const plan = compileCountFieldQueryPlan(this.tableConfig, normalizedWhere, field);
-			if (isAggregatePlanZero(plan)) return [field, 0];
+			const plan = aggregate.compileCountFieldQueryPlan(this.tableConfig, normalizedWhere, field);
+			if (aggregate.isAggregatePlanZero(plan)) return [field, 0];
 			await this._ensureCountIndexReadyOnce(plan.tableName, plan.indexName);
-			return [field, await readCountFieldFromBuckets(this.db, plan)];
+			return [field, await aggregate.readCountFieldFromBuckets(this.db, plan)];
 		}));
 		for (const [field, value] of fieldEntries) result[field] = value;
 		return result;
@@ -6585,6 +3069,7 @@ var GelRelationalQuery = class GelRelationalQuery extends QueryPromise {
 	}
 	async _executeAggregate(config) {
 		const normalized = this._coerceAggregateConfig(config);
+		const aggregate = () => this._aggregate("aggregate()");
 		ensureAggregateAllowedForRls(this.tableConfig, this.rls?.mode, "aggregate()");
 		const result = {};
 		const tasks = [];
@@ -6611,16 +3096,16 @@ var GelRelationalQuery = class GelRelationalQuery extends QueryPromise {
 					}
 				})());
 				countTasks.push(...countSelection.fields.map(async (field) => {
-					const plan = compileAggregateQueryPlan(this.tableConfig, normalized.where, {
+					const plan = aggregate().compileAggregateQueryPlan(this.tableConfig, normalized.where, {
 						kind: "countField",
 						field
 					});
-					if (isAggregatePlanZero(plan)) {
+					if (aggregate().isAggregatePlanZero(plan)) {
 						countResult[field] = 0;
 						return;
 					}
 					await this._ensureAggregateIndexReadyOnce(plan.tableName, plan.indexName);
-					countResult[field] = await readCountFieldFromBuckets(this.db, plan, bucketReadCache);
+					countResult[field] = await aggregate().readCountFieldFromBuckets(this.db, plan, bucketReadCache);
 				}));
 				await Promise.all(countTasks);
 				result._count = countResult;
@@ -6628,50 +3113,50 @@ var GelRelationalQuery = class GelRelationalQuery extends QueryPromise {
 		}
 		if (normalized.sumFields.length > 0) tasks.push((async () => {
 			const sumEntries = await Promise.all(normalized.sumFields.map(async (field) => {
-				const plan = compileAggregateQueryPlan(this.tableConfig, normalized.where, {
+				const plan = aggregate().compileAggregateQueryPlan(this.tableConfig, normalized.where, {
 					kind: "sum",
 					field
 				});
-				if (isAggregatePlanZero(plan)) return [field, null];
+				if (aggregate().isAggregatePlanZero(plan)) return [field, null];
 				await this._ensureAggregateIndexReadyOnce(plan.tableName, plan.indexName);
-				return [field, await readSumFromBuckets(this.db, plan, bucketReadCache)];
+				return [field, await aggregate().readSumFromBuckets(this.db, plan, bucketReadCache)];
 			}));
 			result._sum = Object.fromEntries(sumEntries);
 		})());
 		if (normalized.avgFields.length > 0) tasks.push((async () => {
 			const avgEntries = await Promise.all(normalized.avgFields.map(async (field) => {
-				const plan = compileAggregateQueryPlan(this.tableConfig, normalized.where, {
+				const plan = aggregate().compileAggregateQueryPlan(this.tableConfig, normalized.where, {
 					kind: "avg",
 					field
 				});
-				if (isAggregatePlanZero(plan)) return [field, null];
+				if (aggregate().isAggregatePlanZero(plan)) return [field, null];
 				await this._ensureAggregateIndexReadyOnce(plan.tableName, plan.indexName);
-				return [field, await readAverageFromBuckets(this.db, plan, bucketReadCache)];
+				return [field, await aggregate().readAverageFromBuckets(this.db, plan, bucketReadCache)];
 			}));
 			result._avg = Object.fromEntries(avgEntries);
 		})());
 		if (normalized.minFields.length > 0) tasks.push((async () => {
 			const minEntries = await Promise.all(normalized.minFields.map(async (field) => {
-				const plan = compileAggregateQueryPlan(this.tableConfig, normalized.where, {
+				const plan = aggregate().compileAggregateQueryPlan(this.tableConfig, normalized.where, {
 					kind: "min",
 					field
 				});
-				if (isAggregatePlanZero(plan)) return [field, null];
+				if (aggregate().isAggregatePlanZero(plan)) return [field, null];
 				await this._ensureAggregateIndexReadyOnce(plan.tableName, plan.indexName);
-				const value = await readExtremaFromBuckets(this.db, plan, bucketReadCache);
+				const value = await aggregate().readExtremaFromBuckets(this.db, plan, bucketReadCache);
 				return [field, this._coerceAggregateReturnValue(field, value)];
 			}));
 			result._min = Object.fromEntries(minEntries);
 		})());
 		if (normalized.maxFields.length > 0) tasks.push((async () => {
 			const maxEntries = await Promise.all(normalized.maxFields.map(async (field) => {
-				const plan = compileAggregateQueryPlan(this.tableConfig, normalized.where, {
+				const plan = aggregate().compileAggregateQueryPlan(this.tableConfig, normalized.where, {
 					kind: "max",
 					field
 				});
-				if (isAggregatePlanZero(plan)) return [field, null];
+				if (aggregate().isAggregatePlanZero(plan)) return [field, null];
 				await this._ensureAggregateIndexReadyOnce(plan.tableName, plan.indexName);
-				const value = await readExtremaFromBuckets(this.db, plan, bucketReadCache);
+				const value = await aggregate().readExtremaFromBuckets(this.db, plan, bucketReadCache);
 				return [field, this._coerceAggregateReturnValue(field, value)];
 			}));
 			result._max = Object.fromEntries(maxEntries);
@@ -8065,18 +4550,20 @@ var GelRelationalQuery = class GelRelationalQuery extends QueryPromise {
 		return JSON.stringify(values);
 	}
 	async _readIndexedRelationCount(tableConfig, where, relationPath, bucketCache) {
+		const aggregate = this._aggregate("_count on a relation");
 		ensureCountAllowedForRls(tableConfig, this.rls?.mode);
 		try {
-			const plan = compileCountQueryPlan(tableConfig, where);
-			if (isIndexCountZero(plan)) return 0;
+			const plan = aggregate.compileCountQueryPlan(tableConfig, where);
+			if (aggregate.isIndexCountZero(plan)) return 0;
 			await this._ensureCountIndexReadyOnce(plan.tableName, plan.indexName);
-			return await readCountFromBuckets(this.db, plan, bucketCache);
+			return await aggregate.readCountFromBuckets(this.db, plan, bucketCache);
 		} catch (error) {
 			throw this._remapRelationCountError(error, relationPath);
 		}
 	}
 	async _countRelationForRow(row, relationName, edge, where, tableConfig, caches) {
 		const relationPath = `${tableConfig.name}.${relationName}`;
+		const aggregate = () => this._aggregate("_count on a relation");
 		const bucketCache = caches?.buckets;
 		if (edge.through) {
 			const throughTableConfig = this._getTableConfigByDbName(edge.through.table);
@@ -8098,8 +4585,8 @@ var GelRelationalQuery = class GelRelationalQuery extends QueryPromise {
 			ensureCountAllowedForRls(targetTableConfig, this.rls?.mode);
 			const whereRecord = where;
 			try {
-				const filterPlan = compileCountQueryPlan(targetTableConfig, whereRecord);
-				if (isIndexCountZero(filterPlan)) return 0;
+				const filterPlan = aggregate().compileCountQueryPlan(targetTableConfig, whereRecord);
+				if (aggregate().isIndexCountZero(filterPlan)) return 0;
 				await this._ensureCountIndexReadyOnce(filterPlan.tableName, filterPlan.indexName);
 			} catch (error) {
 				throw this._remapRelationCountError(error, relationPath);
@@ -9672,7 +6159,7 @@ const createNoopLifecycle = () => ({
 	enabled: false,
 	wrapDB: (ctx) => ctx
 });
-function createOrmDbLifecycle(schema, triggerDefinitions) {
+function createOrmDbLifecycle(schema, triggerDefinitions, capabilities) {
 	const tableNameBySchemaKey = /* @__PURE__ */ new Map();
 	const tableNames = /* @__PURE__ */ new Set();
 	for (const [schemaKey, tableConfig] of Object.entries(schema)) {
@@ -9693,12 +6180,13 @@ function createOrmDbLifecycle(schema, triggerDefinitions) {
 		const aggregateIndexes = getAggregateIndexDefinitions(tableConfig);
 		const rankIndexes = getRankIndexDefinitions(tableConfig);
 		if (aggregateIndexes.length === 0 && rankIndexes.length === 0) continue;
+		const aggregate = requireAggregateCapability(capabilities, `Table '${tableConfig.name}' declares an aggregateIndex/rankIndex, which`);
 		const existing = tableHooks.get(tableConfig.name) ?? {};
 		const existingChange = existing.change;
 		const metricIndexNames = aggregateIndexes.map((entry) => entry.name);
 		const rankIndexNames = rankIndexes.map((entry) => entry.name);
 		const prependWriteBarrier = (before) => async (data, ctx) => {
-			await assertAggregateIndexesWritable(ctx.db, tableConfig.name, metricIndexNames, rankIndexNames);
+			await aggregate.assertAggregateIndexesWritable(ctx.db, tableConfig.name, metricIndexNames, rankIndexNames);
 			return before?.(data, ctx);
 		};
 		tableHooks.set(tableConfig.name, {
@@ -9717,21 +6205,21 @@ function createOrmDbLifecycle(schema, triggerDefinitions) {
 			},
 			change: async (change, ctx) => {
 				if (change.operation === "delete") {
-					if (aggregateIndexes.length > 0) await applyAggregateIndexesForChange(ctx.db, tableConfig.name, aggregateIndexes, {
+					if (aggregateIndexes.length > 0) await aggregate.applyAggregateIndexesForChange(ctx.db, tableConfig.name, aggregateIndexes, {
 						operation: "delete",
 						id: change.id
 					});
-					if (rankIndexes.length > 0) await applyRankIndexesForChange(ctx.db, tableConfig.name, rankIndexes, {
+					if (rankIndexes.length > 0) await aggregate.applyRankIndexesForChange(ctx.db, tableConfig.name, rankIndexes, {
 						operation: "delete",
 						id: change.id
 					});
 				} else {
-					if (aggregateIndexes.length > 0) await applyAggregateIndexesForChange(ctx.db, tableConfig.name, aggregateIndexes, {
+					if (aggregateIndexes.length > 0) await aggregate.applyAggregateIndexesForChange(ctx.db, tableConfig.name, aggregateIndexes, {
 						operation: change.operation,
 						id: change.id,
 						newDoc: change.newDoc
 					});
-					if (rankIndexes.length > 0) await applyRankIndexesForChange(ctx.db, tableConfig.name, rankIndexes, {
+					if (rankIndexes.length > 0) await aggregate.applyRankIndexesForChange(ctx.db, tableConfig.name, rankIndexes, {
 						operation: change.operation,
 						id: change.id,
 						newDoc: change.newDoc
@@ -10310,6 +6798,7 @@ function createDatabase(db, schema, edgeMetadata, options) {
 			scheduledMutationBatch: options?.scheduledMutationBatch
 		});
 		const ormContext = {
+			capabilities: options?.capabilities,
 			foreignKeyGraph: getForeignKeyGraph(schema),
 			schema,
 			edgeMetadata,
@@ -10506,665 +6995,6 @@ function isOne(relation) {
 	return relation.relationType === "one";
 }
 
-//#endregion
-//#region src/orm/migrations/definitions.ts
-const MIGRATION_ID_RE = /^[a-zA-Z0-9_:-]+$/;
-const FUNCTION_SOURCE_WHITESPACE_RE = /\s+/g;
-const FUNCTION_SOURCE_PUNCTUATION_SPACE_RE = /\s*([{}();,:])\s*/g;
-function defineMigration(migration) {
-	validateMigrationId(migration.id);
-	validateMigrationStep("up", migration.up);
-	if (migration.down) validateMigrationStep("down", migration.down);
-	return migration;
-}
-function defineMigrationSet(migrations) {
-	const normalized = [...migrations].map((migration) => {
-		const defined = defineMigration(migration);
-		return {
-			...defined,
-			checksum: defined.checksum ?? computeMigrationChecksum(defined)
-		};
-	});
-	normalized.sort((a, b) => a.id.localeCompare(b.id));
-	const byId = {};
-	for (const migration of normalized) {
-		if (byId[migration.id]) throw new Error(`defineMigrationSet received duplicate migration id '${migration.id}'.`);
-		byId[migration.id] = migration;
-	}
-	return {
-		migrations: normalized,
-		ids: normalized.map((migration) => migration.id),
-		byId
-	};
-}
-function detectMigrationDrift(params) {
-	const { migrationSet, appliedState } = params;
-	const issues = [];
-	for (const [migrationId, state] of Object.entries(appliedState)) {
-		if (!state.applied) continue;
-		const migration = migrationSet.byId[migrationId];
-		if (!migration) {
-			issues.push({
-				kind: "missing_from_manifest",
-				migrationId,
-				message: `Applied migration '${migrationId}' is missing from the current migration manifest.`
-			});
-			continue;
-		}
-		if (state.checksum && state.checksum !== migration.checksum) issues.push({
-			kind: "checksum_mismatch",
-			migrationId,
-			expectedChecksum: migration.checksum,
-			actualChecksum: state.checksum,
-			message: `Applied migration '${migrationId}' checksum drift detected.`
-		});
-	}
-	return issues;
-}
-function buildMigrationPlan(params) {
-	const { direction, migrationSet, appliedState, steps, to } = params;
-	if (direction === "up") return {
-		direction,
-		migrations: migrationSet.migrations.filter((migration) => !appliedState[migration.id]?.applied)
-	};
-	if (steps !== void 0 && to !== void 0) throw new Error("Use either down steps or down to, not both.");
-	const appliedInOrder = migrationSet.migrations.filter((migration) => appliedState[migration.id]?.applied);
-	const ensureDownSteps = (selected) => {
-		const missingDown = selected.find((migration) => !migration.down);
-		if (missingDown) throw new Error(`Cannot execute down migration for '${missingDown.id}': missing down migration handler.`);
-		return selected;
-	};
-	if (to) {
-		const targetIndex = migrationSet.ids.indexOf(to);
-		if (targetIndex === -1) throw new Error(`Unknown migration id '${to}' for down --to.`);
-		return {
-			direction,
-			migrations: ensureDownSteps(appliedInOrder.filter((migration) => {
-				return migrationSet.ids.indexOf(migration.id) > targetIndex;
-			})).reverse()
-		};
-	}
-	const resolvedSteps = steps ?? 1;
-	if (!Number.isInteger(resolvedSteps) || resolvedSteps < 1) throw new Error("Down steps must be a positive integer.");
-	return {
-		direction,
-		migrations: ensureDownSteps(appliedInOrder.slice(-resolvedSteps).reverse())
-	};
-}
-function validateMigrationId(id) {
-	if (!id || typeof id !== "string") throw new Error("Migration id must be a non-empty string.");
-	if (!MIGRATION_ID_RE.test(id)) throw new Error(`Migration id '${id}' is invalid. Use alphanumeric characters, '_' ':' or '-'.`);
-}
-function validateMigrationStep(direction, step) {
-	if (!step || typeof step !== "object") throw new Error(`Migration ${direction} step must be an object.`);
-	if (!step.table || typeof step.table !== "string") throw new Error(`Migration ${direction} step.table must be a string.`);
-	if (typeof step.migrateOne !== "function") throw new Error(`Migration ${direction} step.migrateOne must be a function.`);
-	if (step.batchSize !== void 0 && (!Number.isInteger(step.batchSize) || step.batchSize < 1)) throw new Error(`Migration ${direction} step.batchSize must be a positive integer.`);
-	if (step.writeMode !== void 0 && step.writeMode !== "safe_bypass" && step.writeMode !== "normal") throw new Error(`Migration ${direction} step.writeMode must be 'safe_bypass' or 'normal'.`);
-}
-function computeMigrationChecksum(migration) {
-	return simpleStableHash(JSON.stringify({
-		id: migration.id,
-		name: migration.name ?? null,
-		description: migration.description ?? null,
-		up: serializeStep(migration.up),
-		down: migration.down ? serializeStep(migration.down) : null
-	}));
-}
-function serializeStep(step) {
-	return {
-		table: step.table,
-		batchSize: step.batchSize ?? null,
-		writeMode: step.writeMode ?? "safe_bypass",
-		source: normalizeFunctionSource(step.migrateOne)
-	};
-}
-function normalizeFunctionSource(fn) {
-	return fn.toString().replace(FUNCTION_SOURCE_WHITESPACE_RE, " ").replace(FUNCTION_SOURCE_PUNCTUATION_SPACE_RE, "$1").trim();
-}
-function simpleStableHash(value) {
-	let hashA = 2166136261;
-	let hashB = 16777619;
-	for (let i = 0; i < value.length; i += 1) {
-		const code = value.charCodeAt(i);
-		hashA ^= code;
-		hashA = Math.imul(hashA, 16777619);
-		hashB ^= code + i;
-		hashB = Math.imul(hashB, 2246822507);
-	}
-	return `m_${(hashA >>> 0).toString(16).padStart(8, "0")}${(hashB >>> 0).toString(16).padStart(8, "0")}`;
-}
-
-//#endregion
-//#region src/orm/migrations/schema.ts
-const MIGRATION_STATE_TABLE = "migration_state";
-const MIGRATION_RUN_TABLE = "migration_run";
-const migrationStateTable = convexTable(MIGRATION_STATE_TABLE, {
-	migrationId: text().notNull(),
-	checksum: text().notNull(),
-	applied: boolean().notNull(),
-	status: text().notNull(),
-	direction: text(),
-	runId: text(),
-	cursor: text(),
-	processed: integer().notNull(),
-	startedAt: integer(),
-	updatedAt: integer().notNull(),
-	completedAt: integer(),
-	lastError: text(),
-	writeMode: text().notNull()
-}, (t) => [index("by_migration_id").on(t.migrationId), index("by_status").on(t.status)]);
-const migrationRunTable = convexTable(MIGRATION_RUN_TABLE, {
-	runId: text().notNull(),
-	direction: text().notNull(),
-	status: text().notNull(),
-	dryRun: boolean().notNull(),
-	allowDrift: boolean().notNull(),
-	migrationIds: custom(v.array(v.string())).notNull(),
-	currentIndex: integer().notNull(),
-	startedAt: integer().notNull(),
-	updatedAt: integer().notNull(),
-	completedAt: integer(),
-	cancelRequested: boolean().notNull(),
-	lastError: text()
-}, (t) => [index("by_run_id").on(t.runId), index("by_status").on(t.status)]);
-const migrationStorageTables = {
-	[MIGRATION_STATE_TABLE]: migrationStateTable,
-	[MIGRATION_RUN_TABLE]: migrationRunTable
-};
-function migrationExtension() {
-	return defineSchemaExtension("migration", migrationStorageTables);
-}
-
-//#endregion
-//#region src/orm/migrations/runtime.ts
-const DEFAULT_BATCH_SIZE = 128;
-function createMigrationHandlers(params) {
-	const { schema, migrations, getOrm, getChunkRef } = params;
-	const knownTables = new Set(Object.values(schema).map((tableConfig) => tableConfig.name));
-	const run = async (ctx, args = {}) => {
-		if (!migrations || migrations.migrations.length === 0) return {
-			status: "noop",
-			reason: "no_migrations_registered"
-		};
-		const direction = parseDirection(args.direction);
-		const dryRun = args.dryRun === true;
-		const allowDrift = args.allowDrift === true;
-		const restart = args.restart === true;
-		const batchSize = parseOptionalPositiveInteger(args.batchSize, "batchSize");
-		const steps = parseOptionalPositiveInteger(args.steps, "steps");
-		const to = parseOptionalString(args.to, "to");
-		const stateRows = await getAllStateRows(ctx.db);
-		const appliedState = toAppliedStateMap(stateRows);
-		const drift = detectMigrationDrift({
-			migrationSet: migrations,
-			appliedState
-		});
-		if (drift.length > 0 && !allowDrift) return {
-			status: "drift_blocked",
-			direction,
-			drift
-		};
-		const plan = buildMigrationPlan({
-			direction,
-			migrationSet: migrations,
-			appliedState,
-			steps,
-			to
-		});
-		if (plan.migrations.length === 0) return {
-			status: "noop",
-			direction,
-			drift,
-			plan: []
-		};
-		for (const migration of plan.migrations) {
-			const step = getStepForDirection(migration, direction);
-			if (!knownTables.has(step.table)) throw new Error(`Migration '${migration.id}' references unknown table '${step.table}'.`);
-		}
-		if (dryRun) return {
-			status: "dry_run",
-			direction,
-			drift,
-			plan: plan.migrations.map((migration) => migration.id)
-		};
-		const activeRun = await getActiveRun(ctx.db);
-		if (activeRun) return {
-			status: "running",
-			runId: activeRun.runId
-		};
-		const now = Date.now();
-		const runId = createRunId(now);
-		await ctx.db.insert(MIGRATION_RUN_TABLE, {
-			runId,
-			direction,
-			status: "running",
-			dryRun: false,
-			allowDrift,
-			migrationIds: plan.migrations.map((migration) => migration.id),
-			currentIndex: 0,
-			startedAt: now,
-			updatedAt: now,
-			cancelRequested: false
-		});
-		const stateById = new Map(stateRows.map((row) => [row.migrationId, row]));
-		for (const migration of plan.migrations) {
-			const writeMode = getStepForDirection(migration, direction).writeMode ?? "safe_bypass";
-			const existing = stateById.get(migration.id);
-			const resetProgress = restart || existing?.direction !== direction;
-			if (existing) await ctx.db.patch(existing._id, cleanUndefined({
-				checksum: migration.checksum,
-				status: "pending",
-				direction,
-				runId,
-				cursor: resetProgress ? null : existing.cursor ?? null,
-				processed: resetProgress ? 0 : existing.processed ?? 0,
-				startedAt: now,
-				updatedAt: now,
-				completedAt: null,
-				lastError: null,
-				writeMode
-			}));
-			else await ctx.db.insert(MIGRATION_STATE_TABLE, {
-				migrationId: migration.id,
-				checksum: migration.checksum,
-				applied: direction === "down",
-				status: "pending",
-				direction,
-				runId,
-				cursor: null,
-				processed: 0,
-				startedAt: now,
-				updatedAt: now,
-				completedAt: null,
-				lastError: null,
-				writeMode
-			});
-		}
-		if (ctx.scheduler) {
-			const chunkRef = getChunkRef();
-			if (chunkRef) {
-				const chunkArgs = { runId };
-				if (batchSize !== void 0) chunkArgs.batchSize = batchSize;
-				await ctx.scheduler.runAfter(0, chunkRef, chunkArgs);
-				return {
-					status: "running",
-					direction,
-					runId,
-					plan: plan.migrations.map((migration) => migration.id)
-				};
-			}
-		}
-		const inlineResult = await chunk(ctx, {
-			runId,
-			batchSize
-		});
-		return {
-			status: "running",
-			direction,
-			runId,
-			plan: plan.migrations.map((migration) => migration.id),
-			inlineResult
-		};
-	};
-	const chunk = async (ctx, args) => {
-		const runId = parseRequiredString(args.runId, "runId");
-		const batchSize = parseOptionalPositiveInteger(args.batchSize, "batchSize");
-		const runRow = await getRunById(ctx.db, runId);
-		if (!runRow) return {
-			status: "missing",
-			runId
-		};
-		if (runRow.status !== "running") return {
-			status: runRow.status,
-			runId
-		};
-		if (runRow.cancelRequested) {
-			await markRunCanceled(ctx.db, runRow);
-			return {
-				status: "canceled",
-				runId
-			};
-		}
-		const migrationId = runRow.migrationIds[runRow.currentIndex];
-		if (!migrationId) {
-			await markRunCompleted(ctx.db, runRow);
-			return {
-				status: "completed",
-				runId
-			};
-		}
-		const migration = migrations?.byId[migrationId];
-		if (!migration) {
-			await markRunFailed(ctx.db, runRow, `Migration '${migrationId}' is missing from registry.`);
-			return {
-				status: "failed",
-				runId
-			};
-		}
-		const direction = parseDirection(runRow.direction);
-		const step = getStepForDirection(migration, direction);
-		const resolvedBatchSize = batchSize ?? step.batchSize ?? DEFAULT_BATCH_SIZE;
-		const stateRow = await getOrCreateStateRow(ctx.db, migration, direction, step);
-		const cursor = stateRow.cursor ?? null;
-		try {
-			const page = await ctx.db.query(step.table).paginate({
-				cursor,
-				numItems: resolvedBatchSize
-			});
-			const docs = Array.isArray(page?.page) ? page.page : [];
-			const orm = getOrm(ctx);
-			const writeMode = step.writeMode ?? "safe_bypass";
-			let processedInBatch = 0;
-			for (const doc of docs) {
-				const migrationCtxBase = {
-					db: ctx.db,
-					migrationId,
-					runId,
-					direction,
-					dryRun: false,
-					writeMode
-				};
-				const result = await runWithWriteMode(orm, writeMode, (resolvedOrm) => step.migrateOne({
-					...migrationCtxBase,
-					orm: resolvedOrm
-				}, doc));
-				if (isPatchPayload(result) && hasDocId(doc)) await ctx.db.patch(doc._id, result);
-				processedInBatch += 1;
-			}
-			const now = Date.now();
-			const isDone = Boolean(page?.isDone);
-			const nextCursor = isDone ? null : page?.continueCursor ?? null;
-			const nextProcessed = (stateRow.processed ?? 0) + processedInBatch;
-			if (isDone) {
-				await ctx.db.patch(stateRow._id, cleanUndefined({
-					status: "completed",
-					applied: direction === "up",
-					cursor: null,
-					processed: nextProcessed,
-					completedAt: now,
-					updatedAt: now,
-					lastError: null,
-					runId,
-					direction,
-					writeMode
-				}));
-				const nextIndex = runRow.currentIndex + 1;
-				const done = nextIndex >= runRow.migrationIds.length;
-				await ctx.db.patch(runRow._id, cleanUndefined({
-					currentIndex: nextIndex,
-					status: done ? "completed" : "running",
-					updatedAt: now,
-					completedAt: done ? now : null,
-					lastError: null
-				}));
-				if (!done && ctx.scheduler) {
-					const chunkRef = getChunkRef();
-					if (chunkRef) await ctx.scheduler.runAfter(0, chunkRef, {
-						runId,
-						batchSize: resolvedBatchSize
-					});
-				}
-				return {
-					status: done ? "completed" : "running",
-					runId,
-					migrationId,
-					processedInBatch,
-					processed: nextProcessed,
-					currentIndex: nextIndex,
-					total: runRow.migrationIds.length
-				};
-			}
-			await ctx.db.patch(stateRow._id, cleanUndefined({
-				status: "running",
-				cursor: nextCursor,
-				processed: nextProcessed,
-				updatedAt: now,
-				runId,
-				direction,
-				writeMode
-			}));
-			await ctx.db.patch(runRow._id, cleanUndefined({
-				status: "running",
-				updatedAt: now
-			}));
-			if (ctx.scheduler) {
-				const chunkRef = getChunkRef();
-				if (chunkRef) await ctx.scheduler.runAfter(0, chunkRef, {
-					runId,
-					batchSize: resolvedBatchSize
-				});
-			}
-			return {
-				status: "running",
-				runId,
-				migrationId,
-				processedInBatch,
-				processed: nextProcessed,
-				cursor: nextCursor
-			};
-		} catch (error) {
-			const message = error.message || String(error);
-			await ctx.db.patch(stateRow._id, cleanUndefined({
-				status: "failed",
-				lastError: message,
-				updatedAt: Date.now()
-			}));
-			await markRunFailed(ctx.db, runRow, message);
-			return {
-				status: "failed",
-				runId,
-				migrationId,
-				error: message
-			};
-		}
-	};
-	const status = async (ctx, args = {}) => {
-		if (!migrations) return {
-			status: "noop",
-			reason: "no_migrations_registered"
-		};
-		const limit = parseOptionalPositiveInteger(args.limit, "limit") ?? 25;
-		const runId = parseOptionalString(args.runId, "runId");
-		const stateRows = await getAllStateRows(ctx.db);
-		const sortedRuns = [...await getAllRunRows(ctx.db)].sort((left, right) => right.startedAt - left.startedAt);
-		const selectedRuns = runId ? sortedRuns.filter((entry) => entry.runId === runId).slice(0, 1) : sortedRuns.slice(0, limit);
-		const activeRun = sortedRuns.find((entry) => entry.status === "running") ?? null;
-		const appliedState = toAppliedStateMap(stateRows);
-		const drift = detectMigrationDrift({
-			migrationSet: migrations,
-			appliedState
-		});
-		const pendingUp = buildMigrationPlan({
-			direction: "up",
-			migrationSet: migrations,
-			appliedState
-		});
-		return {
-			status: activeRun ? "running" : "idle",
-			activeRun,
-			runs: selectedRuns,
-			migrations: stateRows.map((row) => ({
-				migrationId: row.migrationId,
-				checksum: row.checksum,
-				applied: row.applied,
-				status: row.status,
-				direction: row.direction ?? null,
-				runId: row.runId ?? null,
-				cursor: row.cursor ?? null,
-				processed: row.processed,
-				updatedAt: row.updatedAt,
-				startedAt: row.startedAt ?? null,
-				completedAt: row.completedAt ?? null,
-				lastError: row.lastError ?? null,
-				writeMode: row.writeMode
-			})),
-			pending: pendingUp.migrations.map((migration) => migration.id),
-			drift
-		};
-	};
-	const cancel = async (ctx, args = {}) => {
-		if (!migrations) return {
-			status: "noop",
-			reason: "no_migrations_registered"
-		};
-		const runId = parseOptionalString(args.runId, "runId");
-		const runRow = runId ? await getRunById(ctx.db, runId) : await getActiveRun(ctx.db);
-		if (!runRow) return {
-			status: "noop",
-			reason: "no_active_run"
-		};
-		if (runRow.status !== "running") return {
-			status: "noop",
-			reason: "run_not_running",
-			runId: runRow.runId,
-			runStatus: runRow.status
-		};
-		const now = Date.now();
-		await ctx.db.patch(runRow._id, cleanUndefined({
-			cancelRequested: true,
-			updatedAt: now
-		}));
-		if (!(ctx.scheduler ? getChunkRef() : void 0)) {
-			await markRunCanceled(ctx.db, runRow);
-			return {
-				status: "canceled",
-				runId: runRow.runId
-			};
-		}
-		return {
-			status: "cancel_requested",
-			runId: runRow.runId
-		};
-	};
-	return {
-		run,
-		chunk,
-		status,
-		cancel
-	};
-}
-function getStepForDirection(migration, direction) {
-	if (direction === "up") return migration.up;
-	if (!migration.down) throw new Error(`Migration '${migration.id}' is missing down migration.`);
-	return migration.down;
-}
-function createRunId(now) {
-	return `mr_${now}_${Math.random().toString(36).slice(2, 10)}`;
-}
-function parseDirection(value) {
-	if (value === void 0 || value === null) return "up";
-	if (value === "up" || value === "down") return value;
-	throw new Error("Migration direction must be either 'up' or 'down'.");
-}
-function parseOptionalPositiveInteger(value, fieldName) {
-	if (value === void 0 || value === null) return;
-	if (typeof value !== "number" || !Number.isInteger(value) || value < 1) throw new Error(`Migration ${fieldName} must be a positive integer.`);
-	return value;
-}
-function parseOptionalString(value, fieldName) {
-	if (value === void 0 || value === null) return;
-	if (typeof value !== "string" || value.length === 0) throw new Error(`Migration ${fieldName} must be a non-empty string.`);
-	return value;
-}
-function parseRequiredString(value, fieldName) {
-	const parsed = parseOptionalString(value, fieldName);
-	if (!parsed) throw new Error(`Migration ${fieldName} is required.`);
-	return parsed;
-}
-function toAppliedStateMap(stateRows) {
-	const entries = {};
-	for (const row of stateRows) entries[row.migrationId] = {
-		applied: row.applied,
-		checksum: row.checksum,
-		cursor: row.cursor ?? null,
-		processed: row.processed
-	};
-	return entries;
-}
-async function getAllStateRows(db) {
-	return await db.query(MIGRATION_STATE_TABLE).collect();
-}
-async function getAllRunRows(db) {
-	return await db.query(MIGRATION_RUN_TABLE).collect();
-}
-async function getRunById(db, runId) {
-	return await db.query(MIGRATION_RUN_TABLE).withIndex("by_run_id", (query) => query.eq("runId", runId)).first() ?? null;
-}
-async function getActiveRun(db) {
-	return await db.query(MIGRATION_RUN_TABLE).withIndex("by_status", (query) => query.eq("status", "running")).first() ?? null;
-}
-async function getOrCreateStateRow(db, migration, direction, step) {
-	const existing = await db.query(MIGRATION_STATE_TABLE).withIndex("by_migration_id", (query) => query.eq("migrationId", migration.id)).first();
-	if (existing) return existing;
-	const now = Date.now();
-	const stateId = await db.insert(MIGRATION_STATE_TABLE, {
-		migrationId: migration.id,
-		checksum: migration.checksum,
-		applied: direction === "down",
-		status: "pending",
-		direction,
-		runId: null,
-		cursor: null,
-		processed: 0,
-		startedAt: now,
-		updatedAt: now,
-		completedAt: null,
-		lastError: null,
-		writeMode: step.writeMode ?? "safe_bypass"
-	});
-	const created = await db.get(stateId);
-	if (!created) throw new Error(`Failed to create migration state row for '${migration.id}'.`);
-	return created;
-}
-async function markRunCompleted(db, runRow) {
-	const now = Date.now();
-	await db.patch(runRow._id, cleanUndefined({
-		status: "completed",
-		updatedAt: now,
-		completedAt: now,
-		cancelRequested: false,
-		lastError: null
-	}));
-}
-async function markRunCanceled(db, runRow) {
-	const now = Date.now();
-	await db.patch(runRow._id, cleanUndefined({
-		status: "canceled",
-		updatedAt: now,
-		completedAt: now,
-		cancelRequested: true
-	}));
-	for (const stateRow of await getAllStateRows(db)) if (stateRow.runId === runRow.runId && (stateRow.status === "running" || stateRow.status === "pending")) await db.patch(stateRow._id, cleanUndefined({
-		status: "canceled",
-		updatedAt: now
-	}));
-}
-async function markRunFailed(db, runRow, message) {
-	const now = Date.now();
-	await db.patch(runRow._id, cleanUndefined({
-		status: "failed",
-		updatedAt: now,
-		completedAt: now,
-		lastError: message
-	}));
-}
-async function runWithWriteMode(orm, writeMode, callback) {
-	if (writeMode === "normal") return await callback(orm);
-	return await orm.skipRules.withoutTriggers(async (noTriggersOrm) => {
-		return await callback(noTriggersOrm);
-	});
-}
-function isPatchPayload(value) {
-	return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-function hasDocId(doc) {
-	return "_id" in doc && doc._id !== void 0 && doc._id !== null;
-}
-function cleanUndefined(value) {
-	return Object.fromEntries(Object.entries(value).filter(([, candidate]) => candidate !== void 0));
-}
-
 //#endregion
 //#region src/orm/relations.ts
 var RelationsBuilderTable = class {
@@ -11950,7 +7780,7 @@ function resolveOrmSchemaConfig(schemaInput) {
 		triggers: getSchemaTriggers(schemaInput)
 	};
 }
-function createDbFactory(schema, edgeMetadata, dbLifecycle, ormFunctions) {
+function createDbFactory(schema, edgeMetadata, dbLifecycle, capabilities, ormFunctions) {
 	return ((source, options) => {
 		const ctxSource = isOrmCtx(source) ? source : void 0;
 		const rawDb = ctxSource ? ctxSource.db : source;
@@ -11962,6 +7792,7 @@ function createDbFactory(schema, edgeMetadata, dbLifecycle, ormFunctions) {
 		const wrappedCtx = dbLifecycle.wrapDB(lifecycleSource);
 		const orm = createDatabase(wrappedCtx.db, schema, edgeMetadata, {
 			...options,
+			capabilities,
 			scheduler,
 			vectorSearch,
 			scheduledDelete,
@@ -11974,9 +7805,10 @@ function createDbFactory(schema, edgeMetadata, dbLifecycle, ormFunctions) {
 }
 function createOrm(config) {
 	const { schema: resolvedSchema, triggers } = resolveOrmSchemaConfig(config.schema);
-	const dbLifecycle = createOrmDbLifecycle(resolvedSchema, triggers);
+	const capabilities = resolveOrmCapabilities(config.capabilities);
+	const dbLifecycle = createOrmDbLifecycle(resolvedSchema, triggers, capabilities);
 	const edgeMetadata = extractRelationsConfig(resolvedSchema);
-	const db = createDbFactory(resolvedSchema, edgeMetadata, dbLifecycle, config.ormFunctions);
+	const db = createDbFactory(resolvedSchema, edgeMetadata, dbLifecycle, capabilities, config.ormFunctions);
 	const withContext = (ctx, options) => {
 		const lifecycleCtx = { ...ctx };
 		const wrappedCtx = dbLifecycle.wrapDB(lifecycleCtx);
@@ -11999,8 +7831,10 @@ function createOrm(config) {
 			let aggregateBackfillChunkRef = config.ormFunctions.aggregateBackfillChunk;
 			let migrationRunChunkRef = config.ormFunctions.migrationRunChunk;
 			let resetChunkRef = config.ormFunctions.resetChunk;
-			const countBackfillHandlers = createCountBackfillHandlers(resolvedSchema, () => aggregateBackfillChunkRef);
-			const migrationHandlers = createMigrationHandlers({
+			let countBackfillHandlersCache;
+			const countBackfillHandlers = () => countBackfillHandlersCache ??= requireAggregateCapability(capabilities, "orm.api() aggregate procedures").createCountBackfillHandlers(resolvedSchema, () => aggregateBackfillChunkRef);
+			let migrationHandlersCache;
+			const migrationHandlers = () => migrationHandlersCache ??= requireMigrationCapability(capabilities, "orm.api() migration procedures").createMigrationHandlers({
 				schema: resolvedSchema,
 				migrations: config.migrations,
 				getOrm: (ctx) => db(ctx),
@@ -12008,12 +7842,12 @@ function createOrm(config) {
 			});
 			const aggregateBackfillChunk = mutationBuilder({
 				args: v.any(),
-				handler: countBackfillHandlers.chunk
+				handler: ((ctx, args) => countBackfillHandlers().chunk(ctx, args))
 			});
 			if (!aggregateBackfillChunkRef) aggregateBackfillChunkRef = aggregateBackfillChunk;
 			const migrationRunChunk = mutationBuilder({
 				args: v.any(),
-				handler: migrationHandlers.chunk
+				handler: ((ctx, args) => migrationHandlers().chunk(ctx, args))
 			});
 			if (!migrationRunChunkRef) migrationRunChunkRef = migrationRunChunk;
 			const resetChunk = mutationBuilder({
@@ -12052,25 +7886,25 @@ function createOrm(config) {
 				}),
 				aggregateBackfill: mutationBuilder({
 					args: v.any(),
-					handler: countBackfillHandlers.kickoff
+					handler: ((ctx, args) => countBackfillHandlers().kickoff(ctx, args))
 				}),
 				aggregateBackfillChunk,
 				aggregateBackfillStatus: mutationBuilder({
 					args: v.any(),
-					handler: countBackfillHandlers.status
+					handler: ((ctx, args) => countBackfillHandlers().status(ctx, args))
 				}),
 				migrationRun: mutationBuilder({
 					args: v.any(),
-					handler: migrationHandlers.run
+					handler: ((ctx, args) => migrationHandlers().run(ctx, args))
 				}),
 				migrationRunChunk,
 				migrationStatus: mutationBuilder({
 					args: v.any(),
-					handler: migrationHandlers.status
+					handler: ((ctx, args) => migrationHandlers().status(ctx, args))
 				}),
 				migrationCancel: mutationBuilder({
 					args: v.any(),
-					handler: migrationHandlers.cancel
+					handler: ((ctx, args) => migrationHandlers().cancel(ctx, args))
 				}),
 				resetChunk,
 				reset: internalActionGeneric({