kitcn 0.17.2 → 0.17.4

package/dist/orm/index.js

@@ -350,6 +350,63 @@ const hasUserCreatedAtColumn = (table) => {
 };
 const usesSystemCreatedAtAlias = (_table) => true;
 
+//#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";
@@ -430,23 +487,6 @@ const normalizeTemporalComparableValue = (table, fieldName, value) => {
 	if (Array.isArray(value)) return value.map((entry) => normalizeTemporalWriteValue(descriptor, entry));
 	return normalizeTemporalWriteValue(descriptor, value);
 };
-const normalizePublicSystemFields = (value, options) => {
-	if (!isPlainObject$1(value)) return value;
-	const hasId = Object.hasOwn(value, INTERNAL_ID_FIELD$2);
-	const hasCreationTime = Object.hasOwn(value, INTERNAL_CREATION_TIME_FIELD);
-	if (!hasId && !hasCreationTime) return value;
-	const obj = value;
-	const { [INTERNAL_ID_FIELD$2]: internalId, ...rest } = obj;
-	const publicRow = { ...rest };
-	if (hasId) publicRow[PUBLIC_ID_FIELD$2] = internalId;
-	if (hasCreationTime) {
-		const raw = obj[INTERNAL_CREATION_TIME_FIELD];
-		if (options?.useSystemCreatedAtAlias && raw !== void 0) publicRow[PUBLIC_CREATED_AT_FIELD] = raw;
-		delete publicRow[INTERNAL_CREATION_TIME_FIELD];
-	}
-	delete publicRow[INTERNAL_ID_FIELD$2];
-	return publicRow;
-};
 const normalizeDateFieldsForWrite = (table, value) => {
 	const useSystemCreatedAt = usesSystemCreatedAtAlias(table);
 	const hasUserCreatedAt = hasUserCreatedAtColumn(table);
@@ -460,19 +500,34 @@ const normalizeDateFieldsForWrite = (table, value) => {
 	}
 	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) => {
-	const rawCreationTime = isPlainObject$1(value) && typeof value[INTERNAL_CREATION_TIME_FIELD] === "number" ? value[INTERNAL_CREATION_TIME_FIELD] : void 0;
-	const base = normalizePublicSystemFields(value, { useSystemCreatedAtAlias: usesSystemCreatedAtAlias(table) });
-	if (!isPlainObject$1(base)) return base;
-	const result = { ...base };
+	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);
-	for (const [name, descriptor] of temporalColumns.entries()) {
-		if (name === PUBLIC_CREATED_AT_FIELD && result[name] === void 0 && rawCreationTime !== void 0) {
-			result[name] = hydrateTemporalReadValue(descriptor, rawCreationTime);
+	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;
 		}
-		if (!Object.hasOwn(result, name)) continue;
-		result[name] = hydrateTemporalReadValue(descriptor, result[name]);
+		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;
 };
@@ -996,8 +1051,24 @@ async function softDeleteRow(db, table, row) {
 	await db.patch(tableName, row._id, { deletionTime });
 	return deletionTime;
 }
-async function hardDeleteRow(db, _tableName, row) {
-	await db.delete(row._id);
+/**
+* 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);
@@ -1053,16 +1124,14 @@ async function applyIncomingForeignKeyActionsOnDelete(db, table, row, options) {
 		if (referencingRows.length === 0) continue;
 		if (action === "set null") {
 			ensureNullableColumns(foreignKey.sourceTable, foreignKey.sourceColumns, `Foreign key set null on '${foreignKey.sourceTableName}'`);
-			for (const referencingRow of referencingRows) {
-				const patch = {};
-				for (const columnName of foreignKey.sourceColumns) patch[columnName] = null;
-				await db.patch(foreignKey.sourceTableName, referencingRow._id, patch);
-			}
+			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}'`);
-			for (const referencingRow of referencingRows) await db.patch(foreignKey.sourceTableName, referencingRow._id, defaults);
+			await patchReferencingRows(db, foreignKey.sourceTableName, referencingRows, defaults);
 			continue;
 		}
 		if (action === "cascade") for (const referencingRow of referencingRows) {
@@ -1130,23 +1199,21 @@ async function applyIncomingForeignKeyActionsOnUpdate(db, table, oldRow, newRow,
 		if (referencingRows.length === 0) continue;
 		if (action === "set null") {
 			ensureNullableColumns(foreignKey.sourceTable, foreignKey.sourceColumns, `Foreign key set null on '${foreignKey.sourceTableName}'`);
-			for (const referencingRow of referencingRows) {
-				const patch = {};
-				for (const columnName of foreignKey.sourceColumns) patch[columnName] = null;
-				await db.patch(foreignKey.sourceTableName, referencingRow._id, patch);
-			}
+			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}'`);
-			for (const referencingRow of referencingRows) await db.patch(foreignKey.sourceTableName, referencingRow._id, defaults);
+			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}'`);
-			for (const referencingRow of referencingRows) await db.patch(foreignKey.sourceTableName, referencingRow._id, patchValues);
+			await patchReferencingRows(db, foreignKey.sourceTableName, referencingRows, patchValues);
 		}
 	}
 }
@@ -3424,6 +3491,54 @@ function createCountBackfillHandlers(schema, getChunkRef) {
 	};
 }
 
+//#endregion
+//#region src/orm/query-promise.ts
+/**
+* Query Promise - Lazy query execution via Promise interface
+*
+* Implements Drizzle's QueryPromise pattern:
+* - Queries don't execute until awaited or .then() is called
+* - Implements full Promise interface (then/catch/finally)
+* - Subclasses provide execute() implementation
+*
+* @example
+* const query = ctx.db.query.users.findMany();
+* // Query not executed yet
+* const users = await query; // Now executed
+*/
+/**
+* Abstract base class for promise-based query execution
+*
+* @template T - The result type returned by the query
+*
+* Pattern from Drizzle ORM: query-promise.ts:27-31
+*/
+var QueryPromise = class {
+	/**
+	* Promise tag for debugging and type identification
+	*/
+	[Symbol.toStringTag] = "QueryPromise";
+	/**
+	* Promise.then() implementation - delegates to execute()
+	* This enables lazy evaluation: queries only run when awaited
+	*/
+	then(onFulfilled, onRejected) {
+		return this.execute().then(onFulfilled, onRejected);
+	}
+	/**
+	* Promise.catch() implementation - delegates to execute()
+	*/
+	catch(onRejected) {
+		return this.execute().catch(onRejected);
+	}
+	/**
+	* Promise.finally() implementation - delegates to execute()
+	*/
+	finally(onFinally) {
+		return this.execute().finally(onFinally);
+	}
+};
+
 //#endregion
 //#region src/orm/errors.ts
 var OrmNotFoundError = class extends Error {
@@ -3522,54 +3637,6 @@ async function* streamQuery(ctx, request) {
 }
 const DEFAULT_TARGET_MAX_ROWS = 100;
 
-//#endregion
-//#region src/orm/query-promise.ts
-/**
-* Query Promise - Lazy query execution via Promise interface
-*
-* Implements Drizzle's QueryPromise pattern:
-* - Queries don't execute until awaited or .then() is called
-* - Implements full Promise interface (then/catch/finally)
-* - Subclasses provide execute() implementation
-*
-* @example
-* const query = ctx.db.query.users.findMany();
-* // Query not executed yet
-* const users = await query; // Now executed
-*/
-/**
-* Abstract base class for promise-based query execution
-*
-* @template T - The result type returned by the query
-*
-* Pattern from Drizzle ORM: query-promise.ts:27-31
-*/
-var QueryPromise = class {
-	/**
-	* Promise tag for debugging and type identification
-	*/
-	[Symbol.toStringTag] = "QueryPromise";
-	/**
-	* Promise.then() implementation - delegates to execute()
-	* This enables lazy evaluation: queries only run when awaited
-	*/
-	then(onFulfilled, onRejected) {
-		return this.execute().then(onFulfilled, onRejected);
-	}
-	/**
-	* Promise.catch() implementation - delegates to execute()
-	*/
-	catch(onRejected) {
-		return this.execute().catch(onRejected);
-	}
-	/**
-	* Promise.finally() implementation - delegates to execute()
-	*/
-	finally(onFinally) {
-		return this.execute().finally(onFinally);
-	}
-};
-
 //#endregion
 //#region src/orm/rls/roles.ts
 var RlsRole = class {
@@ -3605,6 +3672,12 @@ function isRlsRole(value) {
 
 //#endregion
 //#region src/orm/rls/evaluator.ts
+function createRlsPolicyResolutionCache() {
+	return {
+		applicable: /* @__PURE__ */ new WeakMap(),
+		expressions: /* @__PURE__ */ new WeakMap()
+	};
+}
 function isRlsEnabled(table) {
 	return Boolean(table[EnableRLS] || getRlsPolicies(table).length > 0);
 }
@@ -3690,22 +3763,52 @@ async function resolveExpression(policy, checkType, ctx, table) {
 	if (typeof candidate === "function") return await candidate(ctx, table);
 	return candidate;
 }
-async function evaluatePolicySet({ table, operation, checkType, row, rls }) {
-	if (!isRlsEnabled(table)) return true;
-	if (rls?.mode === "skip") return true;
+/**
+* The applicable-policy set depends only on `(table, operation, rls)`, never on
+* a row, so it is computed once per cache. `assertRlsRolesResolvable` is folded
+* in to keep the fail-closed ordering: configuration errors still throw before
+* any policy expression is resolved.
+*/
+function getApplicablePolicies(table, operation, rls, cache) {
+	const byOperation = cache.applicable.get(table);
+	const cached = byOperation?.get(operation);
+	if (cached) return cached;
 	assertRlsRolesResolvable({
 		table,
 		operation,
 		rls
 	});
-	const ctx = rls?.ctx ?? {};
 	const policies = getRlsPolicies(table).filter((policy) => policyApplies(policy, operation) && roleMatches(policy, rls));
+	if (byOperation) byOperation.set(operation, policies);
+	else cache.applicable.set(table, new Map([[operation, policies]]));
+	return policies;
+}
+/**
+* Resolved lazily and per policy, so the permissive short-circuit still means a
+* later policy's callback is never invoked. The promise (not the value) is
+* memoized so concurrent rows cannot double-invoke a user callback.
+*/
+function resolveExpressionCached(policy, checkType, ctx, table, cache) {
+	const byCheckType = cache.expressions.get(policy);
+	const cached = byCheckType?.get(checkType);
+	if (cached) return cached;
+	const pending = resolveExpression(policy, checkType, ctx, table);
+	if (byCheckType) byCheckType.set(checkType, pending);
+	else cache.expressions.set(policy, new Map([[checkType, pending]]));
+	return pending;
+}
+async function evaluatePolicySet({ table, operation, checkType, row, rls, cache }) {
+	if (!isRlsEnabled(table)) return true;
+	if (rls?.mode === "skip") return true;
+	const resolution = cache ?? createRlsPolicyResolutionCache();
+	const ctx = rls?.ctx ?? {};
+	const policies = getApplicablePolicies(table, operation, rls, resolution);
 	if (policies.length === 0) return false;
 	const permissive = policies.filter((policy) => (policy.as ?? "permissive") !== "restrictive");
 	if (permissive.length === 0) return false;
 	let permissivePasses = false;
 	for (const policy of permissive) {
-		const expression = await resolveExpression(policy, checkType, ctx, table);
+		const expression = await resolveExpressionCached(policy, checkType, ctx, table, resolution);
 		if (!expression || policyExpressionPasses(row, expression)) {
 			permissivePasses = true;
 			break;
@@ -3714,7 +3817,7 @@ async function evaluatePolicySet({ table, operation, checkType, row, rls }) {
 	if (!permissivePasses) return false;
 	const restrictive = policies.filter((policy) => (policy.as ?? "permissive") === "restrictive");
 	for (const policy of restrictive) {
-		const expression = await resolveExpression(policy, checkType, ctx, table);
+		const expression = await resolveExpressionCached(policy, checkType, ctx, table, resolution);
 		if (!expression) continue;
 		if (!policyExpressionPasses(row, expression)) return false;
 	}
@@ -3726,7 +3829,8 @@ async function canSelectRow(options) {
 		operation: "select",
 		checkType: "using",
 		row: options.row,
-		rls: options.rls
+		rls: options.rls,
+		cache: options.cache
 	});
 }
 async function canInsertRow(options) {
@@ -3735,7 +3839,8 @@ async function canInsertRow(options) {
 		operation: "insert",
 		checkType: "withCheck",
 		row: options.row,
-		rls: options.rls
+		rls: options.rls,
+		cache: options.cache
 	});
 }
 async function canDeleteRow(options) {
@@ -3744,7 +3849,8 @@ async function canDeleteRow(options) {
 		operation: "delete",
 		checkType: "using",
 		row: options.row,
-		rls: options.rls
+		rls: options.rls,
+		cache: options.cache
 	});
 }
 async function evaluateUpdateDecision(options) {
@@ -3753,14 +3859,16 @@ async function evaluateUpdateDecision(options) {
 		operation: "update",
 		checkType: "using",
 		row: options.existingRow,
-		rls: options.rls
+		rls: options.rls,
+		cache: options.cache
 	});
 	const withCheckAllowed = await evaluatePolicySet({
 		table: options.table,
 		operation: "update",
 		checkType: "withCheck",
 		row: options.updatedRow,
-		rls: options.rls
+		rls: options.rls,
+		cache: options.cache
 	});
 	return {
 		allowed: usingAllowed && withCheckAllowed,
@@ -3776,8 +3884,10 @@ async function filterSelectRows(options) {
 		operation: "select",
 		rls: options.rls
 	});
+	const cache = options.cache ?? createRlsPolicyResolutionCache();
 	const rows = [];
 	for (const row of options.rows) if (await canSelectRow({
+		cache,
 		table: options.table,
 		row,
 		rls: options.rls
@@ -4462,11 +4572,37 @@ var GelRankQuery = class {
 *
 * Pattern from Drizzle: gel-core/query-builders/query.ts:32-62
 */
-var GelRelationalQuery = class extends QueryPromise {
+var GelRelationalQuery = class GelRelationalQuery extends QueryPromise {
 	allowFullScan;
-	_countIndexReadinessByKey = /* @__PURE__ */ new Map();
+	/**
+	* Set synchronously by the first `execute()`. Later executions run on a fresh
+	* instance instead, which is what keeps execution-scoped state from leaking
+	* between two awaits of the same query object.
+	*/
+	_executionClaimed = false;
+	/**
+	* Scoped to one execution, because `_executionClaimed` diverts every later
+	* execution to its own instance. Within a run, every `_applyRlsSelectFilter`
+	* call shares it, including the streaming sites that pass a single row at a
+	* time — those would otherwise re-resolve the whole policy set per row.
+	*
+	* SECURITY: a resolved policy expression can embed database state that a
+	* later write invalidates, so it must never outlive the execution that
+	* resolved it.
+	*/
+	_rlsPolicyResolution = createRlsPolicyResolutionCache();
+	/**
+	* Assigned in the constructor so callers that run many short-lived query
+	* instances against the same tables (mutation `returning({ _count })`) can
+	* share one readiness memo instead of re-probing per instance.
+	*/
+	_countIndexReadinessByKey;
+	/**
+	* Index readiness is a probe memo, not execution state, so `_forExecution`
+	* hands it to the next run rather than re-probing.
+	*/
 	_aggregateIndexReadinessByKey = /* @__PURE__ */ new Map();
-	constructor(schema, tableConfig, edgeMetadata, db, config, mode, _allEdges, rls, relationLoading, vectorSearchProvider, configuredIndex) {
+	constructor(schema, tableConfig, edgeMetadata, db, config, mode, _allEdges, rls, relationLoading, vectorSearchProvider, configuredIndex, countIndexReadiness) {
 		super();
 		this.schema = schema;
 		this.tableConfig = tableConfig;
@@ -4480,6 +4616,7 @@ var GelRelationalQuery = class extends QueryPromise {
 		this.vectorSearchProvider = vectorSearchProvider;
 		this.configuredIndex = configuredIndex;
 		this.allowFullScan = config.allowFullScan === true;
+		this._countIndexReadinessByKey = countIndexReadiness ?? /* @__PURE__ */ new Map();
 	}
 	_usesSystemCreatedAtAlias(tableConfig = this.tableConfig) {
 		return usesSystemCreatedAtAlias(tableConfig.table);
@@ -4558,6 +4695,7 @@ var GelRelationalQuery = class extends QueryPromise {
 	async _applyRlsSelectFilter(rows, tableConfig) {
 		if (!tableConfig) return rows;
 		return await filterSelectRows({
+			cache: this._rlsPolicyResolution,
 			table: tableConfig.table,
 			rows,
 			rls: this.rls
@@ -6567,10 +6705,21 @@ var GelRelationalQuery = class extends QueryPromise {
 		return rows;
 	}
 	/**
+	* A second instance of the same query: identical configuration, its own
+	* execution-scoped state, the same index-readiness memos.
+	*/
+	_forExecution() {
+		const next = new GelRelationalQuery(this.schema, this.tableConfig, this.edgeMetadata, this.db, this.config, this.mode, this._allEdges, this.rls, this.relationLoading, this.vectorSearchProvider, this.configuredIndex, this._countIndexReadinessByKey);
+		next._aggregateIndexReadinessByKey = this._aggregateIndexReadinessByKey;
+		return next;
+	}
+	/**
 	* Execute the query and return results
 	* Phase 4 implementation with WhereClauseCompiler integration
 	*/
 	async execute() {
+		if (this._executionClaimed) return this._forExecution().execute();
+		this._executionClaimed = true;
 		const config = this.config;
 		if (this.mode === "count") return await this._executeCount(config);
 		if (this.mode === "aggregate") return await this._executeAggregate(config);
@@ -7295,21 +7444,8 @@ var GelRelationalQuery = class extends QueryPromise {
 		if (!this.allowFullScan) throw new Error(`${baseMessage} Set allowFullScan: true, reduce fan-out, or increase defineSchema(..., { defaults: { relationFanOutMaxKeys } }).`);
 		if (options.tableConfig.strict !== false) console.warn(`${baseMessage} Continuing because allowFullScan: true.`);
 	}
-	async _mapWithConcurrency(items, worker) {
-		if (items.length === 0) return [];
-		const limit = Math.min(this._getRelationConcurrency(), 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: limit }, () => runWorker()));
-		return results;
+	_mapWithConcurrency(items, worker) {
+		return mapWithConcurrency(items, this._getRelationConcurrency(), worker);
 	}
 	/**
 	* Load relations for query results
@@ -7772,7 +7908,16 @@ var GelRelationalQuery = class extends QueryPromise {
 			if (key in tableColumns) throw new Error(`extras.${key} conflicts with a column on table '${tableName}'.`);
 			if (withConfig && key in withConfig) throw new Error(`extras.${key} conflicts with a relation on table '${tableName}'.`);
 		}
-		for (const row of rows) for (const [key, definition] of entries) row[key] = typeof definition === "function" ? definition(this._toPublicRow(row, tableConfig)) : definition;
+		for (const row of rows) {
+			let publicRow;
+			for (const [key, definition] of entries) {
+				if (typeof definition === "function") {
+					publicRow ??= this._toPublicRow(row, tableConfig);
+					row[key] = definition(publicRow);
+				} else row[key] = definition;
+				if (publicRow) publicRow[key] = row[key];
+			}
+		}
 		return rows;
 	}
 	/**
@@ -7810,6 +7955,35 @@ var GelRelationalQuery = class extends QueryPromise {
 	}
 };
 
+//#endregion
+//#region src/orm/returning-count.ts
+/**
+* Builds the `returning({ _count })` reader once per mutation statement.
+*
+* The table config lookup and edge filter are invariant across rows, and — more
+* importantly — the aggregate-index readiness memo lives on the query instance.
+* Constructing a fresh `GelRelationalQuery` per row discarded it, so the
+* readiness probe ran a real indexed collect for every row x counted relation
+* instead of once per (table, index).
+*/
+function createReturningCountLoader(db, table, ormContext) {
+	const schema = ormContext?.schema;
+	const edgeMetadata = ormContext?.edgeMetadata;
+	if (!schema || !edgeMetadata) throw new Error("returning({ _count }) requires orm.db(ctx) configured from createOrm({ schema, ... }).");
+	const tableName = getTableName(table);
+	const tableConfig = Object.values(schema).find((config) => config.name === tableName);
+	if (!tableConfig) throw new Error(`Table config for '${tableName}' is not registered.`);
+	const tableEdges = edgeMetadata.filter((edge) => edge.sourceTable === tableName);
+	const countIndexReadiness = /* @__PURE__ */ new Map();
+	return { async load(row, countSelection) {
+		return (await new GelRelationalQuery(schema, tableConfig, tableEdges, db, {
+			where: { id: row._id },
+			columns: {},
+			with: { _count: countSelection }
+		}, "first", edgeMetadata, ormContext?.rls, ormContext?.relationLoading, void 0, void 0, countIndexReadiness).execute())?._count ?? {};
+	} };
+}
+
 //#endregion
 //#region src/orm/delete.ts
 const applyIndexFilter$1 = (query, filter) => {
@@ -7834,18 +8008,14 @@ var ConvexDeleteBuilder = class extends QueryPromise {
 	scheduledDelayMs;
 	executionModeOverride;
 	paginateConfig;
+	_returningCountLoader;
+	/**
+	* One loader per statement: the table config, edge filter and aggregate-index
+	* readiness memo are invariant across the affected rows.
+	*/
 	async _loadReturningCount(row, countSelection, ormContext) {
-		const schema = ormContext?.schema;
-		const edgeMetadata = ormContext?.edgeMetadata;
-		if (!schema || !edgeMetadata) throw new Error("returning({ _count }) requires orm.db(ctx) configured from createOrm({ schema, ... }).");
-		const tableName = getTableName(this.table);
-		const tableConfig = Object.values(schema).find((config) => config.name === tableName);
-		if (!tableConfig) throw new Error(`Table config for '${tableName}' is not registered.`);
-		return (await new GelRelationalQuery(schema, tableConfig, edgeMetadata.filter((edge) => edge.sourceTable === tableName), this.db, {
-			where: { id: row._id },
-			columns: {},
-			with: { _count: countSelection }
-		}, "first", edgeMetadata, ormContext?.rls, ormContext?.relationLoading).execute())?._count ?? {};
+		this._returningCountLoader ??= createReturningCountLoader(this.db, this.table, ormContext);
+		return await this._returningCountLoader.load(row, countSelection);
 	}
 	constructor(db, table) {
 		super();
@@ -8079,6 +8249,7 @@ var ConvexDeleteBuilder = class extends QueryPromise {
 		const fkBatchSize = isPaginated ? pagination.limit : batchSize;
 		for (const row of rows) {
 			if (!await canDeleteRow({
+				cache: createRlsPolicyResolutionCache(),
 				table: this.table,
 				row,
 				rls
@@ -8151,18 +8322,14 @@ var ConvexInsertBuilder = class extends QueryPromise {
 	returningFields;
 	conflictConfig;
 	allowFullScanFlag = false;
+	_returningCountLoader;
+	/**
+	* One loader per statement: the table config, edge filter and aggregate-index
+	* readiness memo are invariant across the affected rows.
+	*/
 	async _loadReturningCount(row, countSelection, ormContext) {
-		const schema = ormContext?.schema;
-		const edgeMetadata = ormContext?.edgeMetadata;
-		if (!schema || !edgeMetadata) throw new Error("returning({ _count }) requires orm.db(ctx) configured from createOrm({ schema, ... }).");
-		const tableName = getTableName(this.table);
-		const tableConfig = Object.values(schema).find((config) => config.name === tableName);
-		if (!tableConfig) throw new Error(`Table config for '${tableName}' is not registered.`);
-		return (await new GelRelationalQuery(schema, tableConfig, edgeMetadata.filter((edge) => edge.sourceTable === tableName), this.db, {
-			where: { id: row._id },
-			columns: {},
-			with: { _count: countSelection }
-		}, "first", edgeMetadata, ormContext?.rls, ormContext?.relationLoading).execute())?._count ?? {};
+		this._returningCountLoader ??= createReturningCountLoader(this.db, this.table, ormContext);
+		return await this._returningCountLoader.load(row, countSelection);
 	}
 	constructor(db, table) {
 		super();
@@ -8207,12 +8374,14 @@ var ConvexInsertBuilder = class extends QueryPromise {
 			enforcePolymorphicWrite(this.table, preparedValue);
 			const rls = ormContext?.rls;
 			const tableName = getTableName(this.table);
+			const rlsResolution = createRlsPolicyResolutionCache();
 			if (!await canInsertRow({
+				cache: rlsResolution,
 				table: this.table,
 				row: preparedValue,
 				rls
 			})) throw new Error(`RLS policy violation for insert on table "${tableName}"`);
-			const conflictResult = await this.handleConflict(preparedValue);
+			const conflictResult = await this.handleConflict(preparedValue, rlsResolution);
 			if (conflictResult?.status === "skip") continue;
 			if (conflictResult?.status === "updated") {
 				if (conflictResult.row && this.returningFields) results.push(await this.resolveReturningRow(conflictResult.row, returningSelection, ormContext));
@@ -8235,7 +8404,7 @@ var ConvexInsertBuilder = class extends QueryPromise {
 		if (returningSelection?.countSelection) selected._count = await this._loadReturningCount(row, returningSelection.countSelection, ormContext);
 		return selected;
 	}
-	async handleConflict(value) {
+	async handleConflict(value, rlsResolution) {
 		if (!this.conflictConfig) return;
 		const { action, config } = this.conflictConfig;
 		const targetColumns = Array.isArray(config.target) ? config.target : config.target ? [config.target] : [];
@@ -8280,6 +8449,7 @@ var ConvexInsertBuilder = class extends QueryPromise {
 		};
 		const writeSet = normalizeDateFieldsForWrite(this.table, effectiveSet);
 		const updateDecision = await evaluateUpdateDecision({
+			cache: rlsResolution,
 			table: this.table,
 			existingRow: existing,
 			updatedRow: {
@@ -8455,9 +8625,14 @@ const getOrmLifecycleInnerDb = (db) => {
 	return inner;
 };
 const isBeforeDataResult = (value) => typeof value === "object" && value !== null && "data" in value;
+/**
+* FIFO mutex. A re-checking spin over one shared promise wakes every waiter on
+* each release, which costs n(n-1)/2 resumptions for n contenders; handing the
+* lock to exactly one queued waiter costs n-1.
+*/
 var Lock = class {
-	promise = null;
-	resolve = null;
+	locked = false;
+	waiters = [];
 	async withLock(fn) {
 		const unlock = await this.acquire();
 		try {
@@ -8467,15 +8642,20 @@ var Lock = class {
 		}
 	}
 	async acquire() {
-		while (this.promise !== null) await this.promise;
-		let resolve;
-		this.promise = new Promise((res) => {
-			resolve = res;
+		if (this.locked) await new Promise((resolve) => {
+			this.waiters.push(resolve);
 		});
-		this.resolve = resolve;
+		this.locked = true;
+		let released = false;
 		return () => {
-			this.promise = null;
-			this.resolve?.();
+			if (released) return;
+			released = true;
+			const next = this.waiters.shift();
+			if (next) {
+				next();
+				return;
+			}
+			this.locked = false;
 		};
 	}
 };
@@ -8502,6 +8682,69 @@ const withPublicIdAlias = (doc, id) => doc.id !== void 0 ? doc : {
 	...doc,
 	id
 };
+const isPlainRecord = (value) => {
+	if (typeof value !== "object" || value === null) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+};
+/**
+* Convex value serialization drops `undefined` at any depth below the top
+* level, so a document read back from storage never carries a nested
+* `undefined` key. Mirror that when deriving a document locally, otherwise
+* `Object.keys(newDoc)` diverges from what a hook would observe.
+*/
+const stripUndefinedDeep = (value) => {
+	if (Array.isArray(value)) {
+		let changed = false;
+		const next = value.map((entry) => {
+			const stripped = stripUndefinedDeep(entry);
+			if (stripped !== entry) changed = true;
+			return stripped;
+		});
+		return changed ? next : value;
+	}
+	if (!isPlainRecord(value)) return value;
+	let changed = false;
+	const next = {};
+	for (const key of Object.keys(value)) {
+		const nested = value[key];
+		if (nested === void 0) {
+			changed = true;
+			continue;
+		}
+		const stripped = stripUndefinedDeep(nested);
+		if (stripped !== nested) changed = true;
+		next[key] = stripped;
+	}
+	return changed ? next : value;
+};
+/**
+* Reproduce Convex `1.0/shallowMerge`: a top-level shallow merge where a
+* top-level `undefined` removes the key. The stored document is fully
+* determined by the document we already read plus the payload we are about to
+* write, so re-reading it after the patch buys nothing.
+*/
+const applyPatchLocally = (oldDoc, payload) => {
+	const payloadKeys = Object.keys(payload);
+	const removed = /* @__PURE__ */ new Set();
+	for (const key of payloadKeys) if (payload[key] === void 0) removed.add(key);
+	const newDoc = {};
+	for (const key of Object.keys(oldDoc)) {
+		if (removed.has(key)) continue;
+		newDoc[key] = oldDoc[key];
+	}
+	for (const key of payloadKeys) {
+		if (removed.has(key)) continue;
+		newDoc[key] = stripUndefinedDeep(payload[key]);
+	}
+	return newDoc;
+};
+/** Convex owns these; a replace payload can never carry them forward. */
+const applyReplaceLocally = (oldDoc, payload) => ({
+	...stripUndefinedDeep(payload),
+	_id: oldDoc._id,
+	_creationTime: oldDoc._creationTime
+});
 const tableNameFromId = (db, hooksByTable, id) => {
 	for (const tableName of hooksByTable.keys()) if (db.normalizeId(tableName, id)) return tableName;
 	return null;
@@ -8548,18 +8791,16 @@ function writerWithHooks(ctx, innerDb, hooksByTable, isWithinHook = false) {
 		const tableHooks = hooksByTable.get(tableName);
 		if (!tableHooks) return innerDb.patch(tableName, id, value);
 		return executeThenDrainHooks(ctx, innerDb, hooksByTable, isWithinHook, async (hookCtx) => {
-			const oldDoc = await innerDb.get(tableName, id);
+			const needsDocuments = Boolean(tableHooks.update?.after || tableHooks.change);
+			const oldDoc = needsDocuments ? await innerDb.get(tableName, id) : null;
 			const updatePayload = await mergeBeforeData(tableName, "update", tableHooks.update?.before, value, hookCtx);
+			const currentDoc = needsDocuments && tableHooks.update?.before ? await innerDb.get(tableName, id) : oldDoc;
 			await innerDb.patch(tableName, id, updatePayload);
 			if (!oldDoc) return {
 				result: void 0,
 				queuedHooks: []
 			};
-			const newDoc = await innerDb.get(tableName, id);
-			if (!newDoc) return {
-				result: void 0,
-				queuedHooks: []
-			};
+			const newDoc = applyPatchLocally(currentDoc ?? oldDoc, updatePayload);
 			const oldDocWithId = withPublicIdAlias(oldDoc, id);
 			const newDocWithId = withPublicIdAlias(newDoc, id);
 			const change = {
@@ -8595,18 +8836,14 @@ function writerWithHooks(ctx, innerDb, hooksByTable, isWithinHook = false) {
 		const tableHooks = hooksByTable.get(tableName);
 		if (!tableHooks) return innerDb.replace(tableName, id, value);
 		return executeThenDrainHooks(ctx, innerDb, hooksByTable, isWithinHook, async (hookCtx) => {
-			const oldDoc = await innerDb.get(tableName, id);
+			const oldDoc = Boolean(tableHooks.update?.after || tableHooks.change) ? await innerDb.get(tableName, id) : null;
 			const updatePayload = await mergeBeforeData(tableName, "update", tableHooks.update?.before, value, hookCtx);
 			await innerDb.replace(tableName, id, updatePayload);
 			if (!oldDoc) return {
 				result: void 0,
 				queuedHooks: []
 			};
-			const newDoc = await innerDb.get(tableName, id);
-			if (!newDoc) return {
-				result: void 0,
-				queuedHooks: []
-			};
+			const newDoc = applyReplaceLocally(oldDoc, updatePayload);
 			const oldDocWithId = withPublicIdAlias(oldDoc, id);
 			const newDocWithId = withPublicIdAlias(newDoc, id);
 			const change = {
@@ -8634,7 +8871,7 @@ function writerWithHooks(ctx, innerDb, hooksByTable, isWithinHook = false) {
 		const tableHooks = hooksByTable.get(tableName);
 		if (!tableHooks) return innerDb.delete(tableName, id);
 		return executeThenDrainHooks(ctx, innerDb, hooksByTable, isWithinHook, async (hookCtx) => {
-			const oldDoc = await innerDb.get(tableName, id);
+			const oldDoc = Boolean(tableHooks.delete || tableHooks.change) ? await innerDb.get(tableName, id) : null;
 			if (!oldDoc) {
 				await innerDb.delete(tableName, id);
 				return {
@@ -8671,7 +8908,7 @@ function writerWithHooks(ctx, innerDb, hooksByTable, isWithinHook = false) {
 			return executeThenDrainHooks(ctx, innerDb, hooksByTable, isWithinHook, async (hookCtx) => {
 				const insertPayload = await mergeBeforeData(table, "create", tableHooks.create?.before, value, hookCtx);
 				const id = await innerDb.insert(table, insertPayload);
-				const newDoc = await innerDb.get(table, id);
+				const newDoc = Boolean(tableHooks.create?.after || tableHooks.change) ? await innerDb.get(table, id) : null;
 				if (!newDoc) return {
 					result: id,
 					queuedHooks: []
@@ -8768,11 +9005,13 @@ function createOrmDbLifecycle(schema, triggerDefinitions) {
 		});
 	}
 	if (tableHooks.size === 0) return createNoopLifecycle();
+	const hookedTableNames = new Set(tableHooks.keys());
 	return {
 		enabled: true,
 		wrapDB: (ctx) => {
 			if (!isWriterDb(ctx.db) || isLifecycleWrappedDb(ctx.db)) return ctx;
 			const wrappedDb = writerWithHooks(ctx, ctx.db, tableHooks, false);
+			markLifecycleHookedTables(wrappedDb, hookedTableNames);
 			return {
 				...ctx,
 				db: markLifecycleWrappedDb(wrappedDb)
@@ -8977,18 +9216,14 @@ var ConvexUpdateBuilder = class extends QueryPromise {
 	allowFullScanFlag = false;
 	paginateConfig;
 	executionModeOverride;
+	_returningCountLoader;
+	/**
+	* One loader per statement: the table config, edge filter and aggregate-index
+	* readiness memo are invariant across the affected rows.
+	*/
 	async _loadReturningCount(row, countSelection, ormContext) {
-		const schema = ormContext?.schema;
-		const edgeMetadata = ormContext?.edgeMetadata;
-		if (!schema || !edgeMetadata) throw new Error("returning({ _count }) requires orm.db(ctx) configured from createOrm({ schema, ... }).");
-		const tableName = getTableName(this.table);
-		const tableConfig = Object.values(schema).find((config) => config.name === tableName);
-		if (!tableConfig) throw new Error(`Table config for '${tableName}' is not registered.`);
-		return (await new GelRelationalQuery(schema, tableConfig, edgeMetadata.filter((edge) => edge.sourceTable === tableName), this.db, {
-			where: { id: row._id },
-			columns: {},
-			with: { _count: countSelection }
-		}, "first", edgeMetadata, ormContext?.rls, ormContext?.relationLoading).execute())?._count ?? {};
+		this._returningCountLoader ??= createReturningCountLoader(this.db, this.table, ormContext);
+		return await this._returningCountLoader.load(row, countSelection);
 	}
 	constructor(db, table) {
 		super();
@@ -9103,6 +9338,7 @@ var ConvexUpdateBuilder = class extends QueryPromise {
 			operation: "update",
 			rls
 		});
+		const rlsResolution = createRlsPolicyResolutionCache();
 		const onUpdateSet = {};
 		for (const [columnName, builder] of Object.entries(getTableColumns$2(this.table))) {
 			if (columnName in normalizedSetValues) continue;
@@ -9225,6 +9461,7 @@ var ConvexUpdateBuilder = class extends QueryPromise {
 				row,
 				updatedRow,
 				decision: await evaluateUpdateDecision({
+					cache: rlsResolution,
 					table: this.table,
 					existingRow: row,
 					updatedRow,
@@ -10571,14 +10808,12 @@ function scheduledMutationBatchFactory(schema, edgeMetadata, scheduledMutationBa
 		if (workType === "cascade-delete") {
 			if (action === "set null") {
 				ensureNullableColumns(table, sourceColumns, `Foreign key set null on '${args.table}'`);
-				for (const row of rows) {
-					const patch = {};
-					for (const columnName of sourceColumns) patch[columnName] = null;
-					await ctx.db.patch(args.table, row._id, patch);
-				}
+				const nullPatch = {};
+				for (const columnName of sourceColumns) nullPatch[columnName] = null;
+				await patchReferencingRows(ctx.db, args.table, rows, nullPatch);
 			} else if (action === "set default") {
 				const defaults = ensureDefaultColumns(table, sourceColumns, `Foreign key set default on '${args.table}'`);
-				for (const row of rows) await ctx.db.patch(args.table, row._id, defaults);
+				await patchReferencingRows(ctx.db, args.table, rows, defaults);
 			} else if (action === "cascade") {
 				if (!foreignKeyGraph) throw new Error("scheduledMutationBatch: foreign key graph is missing from ORM context.");
 				for (const row of rows) {
@@ -10607,21 +10842,19 @@ function scheduledMutationBatchFactory(schema, edgeMetadata, scheduledMutationBa
 		} else if (workType === "cascade-update") {
 			if (action === "set null") {
 				ensureNullableColumns(table, sourceColumns, `Foreign key set null on '${args.table}'`);
-				for (const row of rows) {
-					const patch = {};
-					for (const columnName of sourceColumns) patch[columnName] = null;
-					await ctx.db.patch(args.table, row._id, patch);
-				}
+				const nullPatch = {};
+				for (const columnName of sourceColumns) nullPatch[columnName] = null;
+				await patchReferencingRows(ctx.db, args.table, rows, nullPatch);
 			} else if (action === "set default") {
 				const defaults = ensureDefaultColumns(table, sourceColumns, `Foreign key set default on '${args.table}'`);
-				for (const row of rows) await ctx.db.patch(args.table, row._id, defaults);
+				await patchReferencingRows(ctx.db, args.table, rows, defaults);
 			} else if (action === "cascade") {
 				const newValues = decodeUndefinedDeep(args.newValues);
 				if (!newValues || !Array.isArray(newValues)) throw new Error("scheduledMutationBatch: newValues are required for cascade update.");
 				const patchValues = {};
 				for (let i = 0; i < sourceColumns.length; i += 1) patchValues[sourceColumns[i]] = newValues[i];
 				ensureNonNullValues(table, patchValues, `Foreign key cascade update on '${args.table}'`);
-				for (const row of rows) await ctx.db.patch(args.table, row._id, patchValues);
+				await patchReferencingRows(ctx.db, args.table, rows, patchValues);
 			}
 		}
 		if (await queryWithIndex().first() !== null || hitByteLimit) await ctx.scheduler.runAfter(args.delayMs, scheduledMutationBatch, {