kitcn 0.24.0 → 0.25.0

package/dist/schema-Besl-rpv.js

@@ -0,0 +1,1411 @@
+import { A as integer, C as index, N as json, O as text, P as objectOf, _ as TableDeleteConfig, a as Columns, j as arrayOf, s as OrmContext, t as convexTable, v as TableName, y as TablePolymorphic } from "./table-rmJm5Qio.js";
+import { t as id } from "./id-Bibg34Yb.js";
+import { C as matchLikePattern, _ as isFieldReference, d as filterValueInList, f as filterValuesEqual, u as fieldRef } from "./filter-expression-Dydt8wS0.js";
+import { t as defineSchemaExtension } from "./extensions-DzjCJXYl.js";
+
+//#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 = "_id";
+const PUBLIC_ID_FIELD = "id";
+const DATE_COLUMN_TYPE = "ConvexDate";
+const TIMESTAMP_COLUMN_TYPE = "ConvexTimestamp";
+const isPlainObject = (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(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(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(value)) return value;
+	const obj = value;
+	const hasId = Object.hasOwn(obj, INTERNAL_ID_FIELD);
+	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 || 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] = obj[INTERNAL_ID_FIELD];
+	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(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(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(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 = 1e3;
+const DEFAULT_AGGREGATE_CARTESIAN_MAX_KEYS = 4096;
+const DEFAULT_AGGREGATE_WORK_BUDGET = 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,
+		aggregateCartesianMaxKeys: defaults?.aggregateCartesianMaxKeys ?? DEFAULT_AGGREGATE_CARTESIAN_MAX_KEYS,
+		aggregateWorkBudget: defaults?.aggregateWorkBudget ?? DEFAULT_AGGREGATE_WORK_BUDGET,
+		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(column) {
+	const name = column.config?.name ?? column?._?.name;
+	if (!name) throw new Error("Column builder is missing a column name");
+	return name;
+}
+function getTableColumns(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(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(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(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(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/aggregate-index/errors.ts
+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 createError = (code, message) => /* @__PURE__ */ new Error(`${code}: ${message}`);
+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);
+};
+
+//#endregion
+//#region src/orm/aggregate-index/definitions.ts
+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 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
+	}));
+};
+
+//#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
+export { serializeFilterExpression as $, ensureNonNullValues as A, getMutationExecutionMode as B, deserializeFilterExpression as C, enforcePolymorphicWrite as D, enforceForeignKeys as E, getChecks as F, getUniqueIndexes as G, getTableColumns as H, getColumnName as I, normalizeDateFieldsForWrite as J, hardDeleteRow as K, getForeignKeys as L, evaluateCheckConstraintTriState as M, evaluateFilter as N, enforceUniqueIndexes as O, extractPrimaryIdLookup as P, selectReturningRowWithHydration as Q, getMutationAsyncDelayMs as R, decodeUndefinedDeep as S, enforceCheckConstraints as T, getTableDeleteConfig as U, getOrmContext as V, getTableName as W, patchReferencingRows as X, normalizeTemporalComparableValue as Y, resolveOrmRuntimeDefaults as Z, applyIncomingForeignKeyActionsOnUpdate as _, usesSystemCreatedAtAlias as _t, aggregateExtension as a, markLifecycleHookedTables as at, collectMutationRowsBounded as b, AGGREGATE_ERROR as c, findSearchIndexByName as ct, createCountError as d, getIndexes as dt, softDeleteRow as et, createError as f, getRankIndexes as ft, applyIncomingForeignKeyActionsOnDelete as g, PUBLIC_CREATED_AT_FIELD as gt, applyDefaults as h, INTERNAL_CREATION_TIME_FIELD as ht, AGGREGATE_STATE_TABLE as i, mapWithConcurrency as it, ensureNullableColumns as j, ensureDefaultColumns as k, COUNT_ERROR as l, findVectorIndexByName as lt, ensureCountAllowedForRls as m, CREATED_AT_MIGRATION_MESSAGE as mt, AGGREGATE_EXTREMA_TABLE as n, takeRowsWithinByteBudget as nt, getAggregateIndexDefinitions as o, findIndexForColumns as ot, ensureAggregateAllowedForRls as p, resolveIndexOrderPushdown as pt, hydrateDateFieldsForRead as q, AGGREGATE_MEMBER_TABLE as r, toConvexFilter as rt, getRankIndexDefinitions as s, findRelationIndex as st, AGGREGATE_BUCKET_TABLE as t, splitReturningSelection as tt, createAggregateError as u, getAggregateIndexes as ut, buildForeignKeyGraph as v, encodeUndefinedDeep as w, collectPrimaryIdLookupRows as x, canUsePrimaryIdLookupCursor as y, getMutationCollectionLimits as z };