@classytic/mongokit 3.12.0 → 3.13.0

package/dist/validation-chain.plugin-BicIgzzt.mjs

@@ -1,4970 +0,0 @@
-import { _ as upsert, a as count, b as LookupBuilder, c as getByQuery, d as deleteById, f as deleteByQuery, h as createMany, l as getOrCreate, m as create, n as update, o as exists, r as updateByQuery, s as getById, t as findOneAndUpdate, x as compileFilterToMongo, y as distinct } from "./update-CDxPtpsk.mjs";
-import { n as debug, r as warn } from "./logger-8-VS1za6.mjs";
-import { n as isDuplicateKeyError, r as parseDuplicateKeyError, t as createError } from "./error-B00pI7dV.mjs";
-import { t as PaginationEngine } from "./PaginationEngine-BDaAsyPn.mjs";
-import { hasNearOperator, rewriteNearForCount } from "./query/primitives/geo.mjs";
-import { r as isValidIdForType, t as getSchemaIdType } from "./id-resolution-e4BT9zAV.mjs";
-import { a as byIdKey, c as listQueryKey, l as modelPattern, o as byQueryKey, r as getFieldsForUser, u as versionKey } from "./field-selection-dI0m4RBs.mjs";
-import { isFilter } from "@classytic/repo-core/filter";
-import mongoose from "mongoose";
-import { HOOK_PRIORITY } from "@classytic/repo-core/hooks";
-import { RepositoryBase, validatePluginOrder } from "@classytic/repo-core/repository";
-import { compileUpdateSpecToMongo, isUpdateSpec } from "@classytic/repo-core/update";
-import { AsyncLocalStorage } from "node:async_hooks";
-//#region src/operations.ts
-/**
-* The registry. Order intentionally groups by category for readability.
-* Adding a new RepositoryOperation requires exactly one entry here, after
-* which every bundled plugin auto-classifies it correctly.
-*/
-const OP_REGISTRY = {
-	create: {
-		policyKey: "data",
-		mutates: true,
-		hasIdContext: false
-	},
-	update: {
-		policyKey: "query",
-		mutates: true,
-		hasIdContext: true
-	},
-	findOneAndUpdate: {
-		policyKey: "query",
-		mutates: true,
-		hasIdContext: false
-	},
-	delete: {
-		policyKey: "query",
-		mutates: true,
-		hasIdContext: true
-	},
-	restore: {
-		policyKey: "query",
-		mutates: true,
-		hasIdContext: true
-	},
-	createMany: {
-		policyKey: "dataArray",
-		mutates: true,
-		hasIdContext: false
-	},
-	updateMany: {
-		policyKey: "query",
-		mutates: true,
-		hasIdContext: false
-	},
-	deleteMany: {
-		policyKey: "query",
-		mutates: true,
-		hasIdContext: false
-	},
-	bulkWrite: {
-		policyKey: "operations",
-		mutates: true,
-		hasIdContext: false
-	},
-	getById: {
-		policyKey: "query",
-		mutates: false,
-		hasIdContext: true
-	},
-	getByQuery: {
-		policyKey: "query",
-		mutates: false,
-		hasIdContext: false
-	},
-	getOne: {
-		policyKey: "query",
-		mutates: false,
-		hasIdContext: false
-	},
-	findAll: {
-		policyKey: "query",
-		mutates: false,
-		hasIdContext: false
-	},
-	getOrCreate: {
-		policyKey: "query",
-		mutates: false,
-		hasIdContext: false
-	},
-	count: {
-		policyKey: "query",
-		mutates: false,
-		hasIdContext: false
-	},
-	exists: {
-		policyKey: "query",
-		mutates: false,
-		hasIdContext: false
-	},
-	distinct: {
-		policyKey: "query",
-		mutates: false,
-		hasIdContext: false
-	},
-	aggregate: {
-		policyKey: "query",
-		mutates: false,
-		hasIdContext: false
-	},
-	aggregatePipeline: {
-		policyKey: "query",
-		mutates: false,
-		hasIdContext: false
-	},
-	getAll: {
-		policyKey: "filters",
-		mutates: false,
-		hasIdContext: false
-	},
-	aggregatePaginate: {
-		policyKey: "filters",
-		mutates: false,
-		hasIdContext: false
-	},
-	aggregatePipelinePaginate: {
-		policyKey: "filters",
-		mutates: false,
-		hasIdContext: false
-	},
-	lookupPopulate: {
-		policyKey: "filters",
-		mutates: false,
-		hasIdContext: false
-	}
-};
-/** All known repository operations, in registry order. */
-const ALL_OPERATIONS = Object.keys(OP_REGISTRY);
-/** Operations that mutate the database. Drives audit + cache invalidation lists. */
-const MUTATING_OPERATIONS = ALL_OPERATIONS.filter((op) => OP_REGISTRY[op].mutates);
-/** Operations that don't mutate. Drives default cacheable ops. */
-const READ_OPERATIONS = ALL_OPERATIONS.filter((op) => !OP_REGISTRY[op].mutates);
-/** Filter ops by their policy injection key. */
-function operationsByPolicyKey(key) {
-	return ALL_OPERATIONS.filter((op) => OP_REGISTRY[op].policyKey === key);
-}
-//#endregion
-//#region src/plugins/aggregate-helpers.plugin.ts
-/**
-* Aggregate helpers plugin
-*
-* @example
-* const repo = new Repository(Model, [
-*   methodRegistryPlugin(),
-*   aggregateHelpersPlugin(),
-* ]);
-*
-* const groups = await repo.groupBy('category');
-* const total = await repo.sum('amount', { status: 'completed' });
-*/
-function aggregateHelpersPlugin() {
-	return {
-		name: "aggregate-helpers",
-		apply(repo) {
-			if (!repo.registerMethod) throw new Error("aggregateHelpersPlugin requires methodRegistryPlugin");
-			/**
-			* Group by field
-			*/
-			repo.registerMethod("groupBy", async function(field, options = {}) {
-				const pipeline = [{ $group: {
-					_id: `$${field}`,
-					count: { $sum: 1 }
-				} }, { $sort: { count: -1 } }];
-				if (options.limit) pipeline.push({ $limit: options.limit });
-				return this.aggregatePipeline(pipeline, options);
-			});
-			const aggregateOperation = async function(field, operator, resultKey, query = {}, options = {}) {
-				const pipeline = [{ $match: query }, { $group: {
-					_id: null,
-					[resultKey]: { [operator]: `$${field}` }
-				} }];
-				return (await this.aggregatePipeline(pipeline, options))[0]?.[resultKey] || 0;
-			};
-			/**
-			* Sum field values
-			*/
-			repo.registerMethod("sum", async function(field, query = {}, options = {}) {
-				return aggregateOperation.call(this, field, "$sum", "total", query, options);
-			});
-			/**
-			* Average field values
-			*/
-			repo.registerMethod("average", async function(field, query = {}, options = {}) {
-				return aggregateOperation.call(this, field, "$avg", "avg", query, options);
-			});
-			/**
-			* Get minimum value
-			*/
-			repo.registerMethod("min", async function(field, query = {}, options = {}) {
-				return aggregateOperation.call(this, field, "$min", "min", query, options);
-			});
-			/**
-			* Get maximum value
-			*/
-			repo.registerMethod("max", async function(field, query = {}, options = {}) {
-				return aggregateOperation.call(this, field, "$max", "max", query, options);
-			});
-		}
-	};
-}
-//#endregion
-//#region src/plugins/audit-log.plugin.ts
-/**
-* Audit log plugin that logs all repository operations
-*
-* @example
-* const repo = new Repository(Model, [auditLogPlugin(console)]);
-*/
-function auditLogPlugin(logger) {
-	return {
-		name: "auditLog",
-		apply(repo) {
-			repo.on("after:create", ({ context, result }) => {
-				const idKey = repo.idField || "_id";
-				logger?.info?.("Document created", {
-					model: context.model || repo.model,
-					id: result?.[idKey],
-					userId: context.user?._id || context.user?.id,
-					organizationId: context.organizationId
-				});
-			});
-			repo.on("after:update", ({ context, result }) => {
-				logger?.info?.("Document updated", {
-					model: context.model || repo.model,
-					id: context.id || result?.[repo.idField || "_id"],
-					userId: context.user?._id || context.user?.id,
-					organizationId: context.organizationId
-				});
-			});
-			repo.on("after:findOneAndUpdate", ({ context, result }) => {
-				if (!result) return;
-				logger?.info?.("Document upserted/updated (findOneAndUpdate)", {
-					model: context.model || repo.model,
-					id: result?.[repo.idField || "_id"],
-					userId: context.user?._id || context.user?.id,
-					organizationId: context.organizationId
-				});
-			});
-			repo.on("error:findOneAndUpdate", ({ context, error }) => {
-				logger?.error?.("findOneAndUpdate failed", {
-					model: context.model || repo.model,
-					error: error.message,
-					userId: context.user?._id || context.user?.id
-				});
-			});
-			repo.on("after:delete", ({ context }) => {
-				logger?.info?.("Document deleted", {
-					model: context.model || repo.model,
-					id: context.id,
-					userId: context.user?._id || context.user?.id,
-					organizationId: context.organizationId
-				});
-			});
-			repo.on("error:create", ({ context, error }) => {
-				logger?.error?.("Create failed", {
-					model: context.model || repo.model,
-					error: error.message,
-					userId: context.user?._id || context.user?.id
-				});
-			});
-			repo.on("error:update", ({ context, error }) => {
-				logger?.error?.("Update failed", {
-					model: context.model || repo.model,
-					id: context.id,
-					error: error.message,
-					userId: context.user?._id || context.user?.id
-				});
-			});
-			repo.on("error:delete", ({ context, error }) => {
-				logger?.error?.("Delete failed", {
-					model: context.model || repo.model,
-					id: context.id,
-					error: error.message,
-					userId: context.user?._id || context.user?.id
-				});
-			});
-		}
-	};
-}
-//#endregion
-//#region src/plugins/audit-trail.plugin.ts
-/**
-* Audit Trail Plugin
-*
-* Persists operation audit entries to a MongoDB collection.
-* Fire-and-forget: writes happen async and never block or fail the main operation.
-*
-* Features:
-* - Tracks create, update, delete operations
-* - Field-level change tracking (before/after diff on updates)
-* - TTL auto-cleanup via MongoDB TTL index
-* - Custom metadata per entry (IP, user-agent, etc.)
-* - Shared `audit_trails` collection across all models
-*
-* @example
-* ```typescript
-* const repo = new Repository(Job, [
-*   auditTrailPlugin({
-*     operations: ['create', 'update', 'delete'],
-*     trackChanges: true,
-*     ttlDays: 90,
-*     metadata: (context) => ({
-*       ip: context.req?.ip,
-*     }),
-*   }),
-* ]);
-* ```
-*/
-const modelCache = /* @__PURE__ */ new Map();
-function getAuditModel(collectionName, ttlDays) {
-	const existing = modelCache.get(collectionName);
-	if (existing) return existing;
-	const schema = new mongoose.Schema({
-		model: {
-			type: String,
-			required: true,
-			index: true
-		},
-		operation: {
-			type: String,
-			required: true,
-			enum: [
-				"create",
-				"update",
-				"findOneAndUpdate",
-				"delete"
-			]
-		},
-		documentId: {
-			type: mongoose.Schema.Types.Mixed,
-			required: true,
-			index: true
-		},
-		userId: {
-			type: mongoose.Schema.Types.Mixed,
-			index: true
-		},
-		orgId: {
-			type: mongoose.Schema.Types.Mixed,
-			index: true
-		},
-		changes: { type: mongoose.Schema.Types.Mixed },
-		document: { type: mongoose.Schema.Types.Mixed },
-		metadata: { type: mongoose.Schema.Types.Mixed },
-		timestamp: {
-			type: Date,
-			default: Date.now,
-			index: true
-		}
-	}, {
-		collection: collectionName,
-		versionKey: false
-	});
-	schema.index({
-		model: 1,
-		documentId: 1,
-		timestamp: -1
-	});
-	schema.index({
-		orgId: 1,
-		userId: 1,
-		timestamp: -1
-	});
-	if (ttlDays !== void 0 && ttlDays > 0) {
-		const ttlSeconds = ttlDays * 24 * 60 * 60;
-		schema.index({ timestamp: 1 }, { expireAfterSeconds: ttlSeconds });
-	}
-	const modelName = `AuditTrail_${collectionName}`;
-	const model = mongoose.models[modelName] || mongoose.model(modelName, schema);
-	modelCache.set(collectionName, model);
-	return model;
-}
-/** Compute field-level diff between previous and updated document */
-function computeChanges(prev, next, excludeFields) {
-	const changes = {};
-	const exclude = new Set(excludeFields);
-	for (const key of Object.keys(next)) {
-		if (exclude.has(key)) continue;
-		if (key === "_id" || key === "__v" || key === "updatedAt") continue;
-		const prevVal = prev[key];
-		const nextVal = next[key];
-		if (!deepEqual(prevVal, nextVal)) changes[key] = {
-			from: prevVal,
-			to: nextVal
-		};
-	}
-	return Object.keys(changes).length > 0 ? changes : void 0;
-}
-/** Simple deep equality check for audit diffing */
-function deepEqual(a, b) {
-	if (a === b) return true;
-	if (a == null && b == null) return true;
-	if (a == null || b == null) return false;
-	if (typeof a === "object" && typeof b === "object") {
-		const aStr = a.toString?.();
-		const bStr = b.toString?.();
-		if (aStr && bStr && aStr === bStr) return true;
-	}
-	if (a instanceof Date && b instanceof Date) return a.getTime() === b.getTime();
-	try {
-		return JSON.stringify(a) === JSON.stringify(b);
-	} catch {
-		return false;
-	}
-}
-/** Extract user ID from context */
-function getUserId(context) {
-	return context.user?._id || context.user?.id;
-}
-/** Fire-and-forget: write audit entry, never throw */
-function writeAudit(AuditModel, entry) {
-	Promise.resolve().then(() => {
-		AuditModel.create({
-			...entry,
-			timestamp: /* @__PURE__ */ new Date()
-		}).catch((err) => {
-			warn(`[auditTrailPlugin] Failed to write audit entry: ${err.message}`);
-		});
-	});
-}
-const snapshots = /* @__PURE__ */ new WeakMap();
-function auditTrailPlugin(options = {}) {
-	const { operations = [
-		"create",
-		"update",
-		"delete"
-	], trackChanges = true, trackDocument = false, ttlDays, collectionName = "audit_trails", metadata, excludeFields = [] } = options;
-	const opsSet = new Set(operations);
-	return {
-		name: "auditTrail",
-		apply(repo) {
-			const AuditModel = getAuditModel(collectionName, ttlDays);
-			if (opsSet.has("create")) repo.on("after:create", ({ context, result }) => {
-				const doc = toPlainObject(result);
-				const idKey = repo.idField || "_id";
-				writeAudit(AuditModel, {
-					model: context.model || repo.model,
-					operation: "create",
-					documentId: doc?.[idKey],
-					userId: getUserId(context),
-					orgId: context.organizationId,
-					document: trackDocument ? sanitizeDoc(doc, excludeFields) : void 0,
-					metadata: metadata?.(context)
-				});
-			});
-			if (opsSet.has("update")) {
-				if (trackChanges) repo.on("before:update", async (context) => {
-					if (!context.id) return;
-					try {
-						const prev = await repo.Model.findById(context.id).lean();
-						if (prev) snapshots.set(context, prev);
-					} catch (err) {
-						warn(`[auditTrailPlugin] Failed to snapshot before update: ${err.message}`);
-					}
-				});
-				repo.on("after:update", ({ context, result }) => {
-					const doc = result;
-					let changes;
-					if (trackChanges) {
-						const prev = snapshots.get(context);
-						if (prev && context.data) changes = computeChanges(prev, context.data, excludeFields);
-						snapshots.delete(context);
-					}
-					writeAudit(AuditModel, {
-						model: context.model || repo.model,
-						operation: "update",
-						documentId: context.id || doc?.[repo.idField || "_id"],
-						userId: getUserId(context),
-						orgId: context.organizationId,
-						changes,
-						metadata: metadata?.(context)
-					});
-				});
-			}
-			if (opsSet.has("findOneAndUpdate")) repo.on("after:findOneAndUpdate", ({ context, result }) => {
-				if (!result) return;
-				const doc = result;
-				const idKey = repo.idField || "_id";
-				writeAudit(AuditModel, {
-					model: context.model || repo.model,
-					operation: "findOneAndUpdate",
-					documentId: doc?.[idKey],
-					userId: getUserId(context),
-					orgId: context.organizationId,
-					metadata: metadata?.(context)
-				});
-			});
-			if (opsSet.has("delete")) repo.on("after:delete", ({ context }) => {
-				writeAudit(AuditModel, {
-					model: context.model || repo.model,
-					operation: "delete",
-					documentId: context.id,
-					userId: getUserId(context),
-					orgId: context.organizationId,
-					metadata: metadata?.(context)
-				});
-			});
-			if (typeof repo.registerMethod === "function")
- /**
-			* Get audit trail for a specific document
-			*/
-			repo.registerMethod("getAuditTrail", async function(documentId, queryOptions = {}) {
-				const { page = 1, limit = 20, operation } = queryOptions;
-				const skip = (page - 1) * limit;
-				const filter = {
-					model: this.model,
-					documentId
-				};
-				if (operation) filter.operation = operation;
-				const [docs, total] = await Promise.all([AuditModel.find(filter).sort({ timestamp: -1 }).skip(skip).limit(limit).lean(), AuditModel.countDocuments(filter)]);
-				return {
-					docs,
-					page,
-					limit,
-					total,
-					pages: Math.ceil(total / limit),
-					hasNext: page < Math.ceil(total / limit),
-					hasPrev: page > 1
-				};
-			});
-		}
-	};
-}
-/** Convert Mongoose document to plain object */
-function toPlainObject(doc) {
-	if (!doc) return {};
-	if (typeof doc.toObject === "function") return doc.toObject();
-	return doc;
-}
-/** Remove excluded fields from a document snapshot */
-function sanitizeDoc(doc, excludeFields) {
-	if (excludeFields.length === 0) return doc;
-	const result = { ...doc };
-	for (const field of excludeFields) delete result[field];
-	return result;
-}
-/**
-* Standalone audit trail query utility.
-* Use this to query audits across all models — e.g., admin dashboards, audit APIs.
-*
-* @example
-* ```typescript
-* import { AuditTrailQuery } from '@classytic/mongokit';
-*
-* const auditQuery = new AuditTrailQuery(); // defaults to 'audit_trails' collection
-*
-* // All audits for an org
-* const orgAudits = await auditQuery.query({ orgId: '...' });
-*
-* // All updates by a user
-* const userUpdates = await auditQuery.query({
-*   userId: '...',
-*   operation: 'update',
-* });
-*
-* // All audits for a specific document
-* const docHistory = await auditQuery.query({
-*   model: 'Job',
-*   documentId: '...',
-* });
-*
-* // Date range
-* const recent = await auditQuery.query({
-*   from: new Date('2025-01-01'),
-*   to: new Date(),
-*   page: 1,
-*   limit: 50,
-* });
-*
-* // Direct model access for custom queries
-* const model = auditQuery.getModel();
-* const count = await model.countDocuments({ operation: 'delete' });
-* ```
-*/
-var AuditTrailQuery = class {
-	model;
-	constructor(collectionName = "audit_trails", ttlDays) {
-		this.model = getAuditModel(collectionName, ttlDays);
-	}
-	/**
-	* Get the underlying Mongoose model for custom queries
-	*/
-	getModel() {
-		return this.model;
-	}
-	/**
-	* Query audit entries with filters and pagination
-	*/
-	async query(options = {}) {
-		const { page = 1, limit = 20 } = options;
-		const skip = (page - 1) * limit;
-		const filter = {};
-		if (options.model) filter.model = options.model;
-		if (options.documentId) filter.documentId = options.documentId;
-		if (options.userId) filter.userId = options.userId;
-		if (options.orgId) filter.orgId = options.orgId;
-		if (options.operation) filter.operation = options.operation;
-		if (options.from || options.to) {
-			const dateFilter = {};
-			if (options.from) dateFilter.$gte = options.from;
-			if (options.to) dateFilter.$lte = options.to;
-			filter.timestamp = dateFilter;
-		}
-		const [docs, total] = await Promise.all([this.model.find(filter).sort({ timestamp: -1 }).skip(skip).limit(limit).lean(), this.model.countDocuments(filter)]);
-		const pages = Math.ceil(total / limit);
-		return {
-			docs,
-			page,
-			limit,
-			total,
-			pages,
-			hasNext: page < pages,
-			hasPrev: page > 1
-		};
-	}
-	/**
-	* Get audit trail for a specific document
-	*/
-	async getDocumentTrail(model, documentId, options = {}) {
-		return this.query({
-			model,
-			documentId,
-			...options
-		});
-	}
-	/**
-	* Get all audits for a user
-	*/
-	async getUserTrail(userId, options = {}) {
-		return this.query({
-			userId,
-			...options
-		});
-	}
-	/**
-	* Get all audits for an organization
-	*/
-	async getOrgTrail(orgId, options = {}) {
-		return this.query({
-			orgId,
-			...options
-		});
-	}
-};
-//#endregion
-//#region src/plugins/batch-operations.plugin.ts
-/**
-* Batch operations plugin.
-*
-* @example
-* const repo = new Repository(Model, [
-*   methodRegistryPlugin(),
-*   batchOperationsPlugin(),
-* ]);
-*
-* // updateMany + deleteMany are primitives on Repository — no plugin needed.
-* await repo.updateMany({ status: 'pending' }, { status: 'active' });
-* await repo.deleteMany({ status: 'deleted' });
-*
-* // bulkWrite is what this plugin contributes.
-* await repo.bulkWrite([...ops]);
-*/
-function batchOperationsPlugin() {
-	return {
-		name: "batch-operations",
-		apply(repo) {
-			if (!repo.registerMethod) throw new Error("batchOperationsPlugin requires methodRegistryPlugin");
-			/**
-			* Execute heterogeneous bulk write operations in a single database call.
-			*
-			* Supports insertOne, updateOne, updateMany, deleteOne, deleteMany, and replaceOne
-			* operations mixed together for maximum efficiency.
-			*
-			* @example
-			* await repo.bulkWrite([
-			*   { insertOne: { document: { name: 'New Item', price: 10 } } },
-			*   { updateOne: { filter: { _id: id1 }, update: { $inc: { views: 1 } } } },
-			*   { updateMany: { filter: { status: 'draft' }, update: { $set: { status: 'published' } } } },
-			*   { deleteOne: { filter: { _id: id2 } } },
-			* ]);
-			*/
-			repo.registerMethod("bulkWrite", async function(operations, options = {}) {
-				const context = await this._buildContext("bulkWrite", {
-					operations,
-					...options
-				});
-				try {
-					const finalOps = context.operations || operations;
-					if (!finalOps || finalOps.length === 0) throw createError(400, "bulkWrite requires at least one operation");
-					const result = await this.Model.bulkWrite(finalOps, {
-						ordered: options.ordered ?? true,
-						session: options.session
-					});
-					const bulkResult = {
-						ok: result.ok,
-						insertedCount: result.insertedCount,
-						upsertedCount: result.upsertedCount,
-						matchedCount: result.matchedCount,
-						modifiedCount: result.modifiedCount,
-						deletedCount: result.deletedCount,
-						insertedIds: result.insertedIds,
-						upsertedIds: result.upsertedIds
-					};
-					await this.emitAsync("after:bulkWrite", {
-						context,
-						result: bulkResult
-					});
-					return bulkResult;
-				} catch (error) {
-					this.emit("error:bulkWrite", {
-						context,
-						error
-					});
-					throw this._handleError(error);
-				}
-			});
-		}
-	};
-}
-//#endregion
-//#region src/actions/aggregate-ir/normalize.ts
-/**
-* Normalize `AggRequest['groupBy']` into a readonly string array.
-* Returns `[]` for scalar aggregation (no groupBy). Downstream
-* compilers treat `[]` uniformly — one `$group: { _id: null, ... }`
-* stage, no per-key projection.
-*/
-function normalizeGroupBy(groupBy) {
-	if (!groupBy) return [];
-	if (typeof groupBy === "string") return [groupBy];
-	return groupBy;
-}
-/**
-* Fail loud on an empty measures bag — there's nothing to compute and
-* the caller's code path is almost certainly a wiring bug (conditional
-* collapsed, key renamed, etc.). Silently returning `{ rows: [] }`
-* would mask it.
-*/
-function validateMeasures(measures) {
-	if (!measures || Object.keys(measures).length === 0) throw new Error("mongokit/aggregate: AggRequest requires at least one measure — empty measures bag is a wiring bug");
-}
-//#endregion
-//#region src/actions/aggregate-ir/measure.ts
-function compileMeasure(measure) {
-	switch (measure.op) {
-		case "count":
-			if (!measure.field || measure.field === "*") return { groupExpr: { $sum: 1 } };
-			return { groupExpr: { $sum: { $cond: [
-				{ $ne: [`$${measure.field}`, null] },
-				1,
-				0
-			] } } };
-		case "countDistinct": return {
-			groupExpr: { $addToSet: `$${measure.field}` },
-			projectExpr: { $size: { $ifNull: ["$$CURRENT", []] } }
-		};
-		case "sum": return { groupExpr: { $sum: `$${measure.field}` } };
-		case "avg": return { groupExpr: { $avg: `$${measure.field}` } };
-		case "min": return { groupExpr: { $min: `$${measure.field}` } };
-		case "max": return { groupExpr: { $max: `$${measure.field}` } };
-	}
-}
-//#endregion
-//#region src/actions/aggregate-ir/pipeline.ts
-function buildAggPipeline(req) {
-	validateMeasures(req.measures);
-	const groupCols = normalizeGroupBy(req.groupBy);
-	const stages = [];
-	if (req.filter) {
-		const match = compileFilterToMongo(req.filter);
-		if (Object.keys(match).length > 0) stages.push({ $match: match });
-	}
-	const groupStage = { _id: groupCols.length === 0 ? null : groupCols.reduce((acc, field) => {
-		acc[field] = `$${field}`;
-		return acc;
-	}, {}) };
-	const distinctSetAliases = [];
-	for (const [alias, measure] of Object.entries(req.measures)) {
-		groupStage[alias] = compileMeasure(measure).groupExpr;
-		if (measure.op === "countDistinct") distinctSetAliases.push(alias);
-	}
-	stages.push({ $group: groupStage });
-	if (distinctSetAliases.length > 0) {
-		const addFields = {};
-		for (const alias of distinctSetAliases) addFields[alias] = { $size: { $ifNull: [`$${alias}`, []] } };
-		stages.push({ $addFields: addFields });
-	}
-	const projection = { _id: 0 };
-	for (const field of groupCols) projection[field] = `$_id.${field}`;
-	for (const alias of Object.keys(req.measures)) projection[alias] = 1;
-	stages.push({ $project: projection });
-	if (req.having) {
-		const match = compileFilterToMongo(req.having);
-		if (Object.keys(match).length > 0) stages.push({ $match: match });
-	}
-	const prePaginationIndex = stages.length;
-	if (req.sort) stages.push({ $sort: req.sort });
-	if (typeof req.offset === "number" && req.offset > 0) stages.push({ $skip: req.offset });
-	if (typeof req.limit === "number") stages.push({ $limit: req.limit });
-	return {
-		pipeline: stages,
-		prePaginationIndex
-	};
-}
-//#endregion
-//#region src/actions/aggregate-ir/count.ts
-async function countAggGroups(Model, req, options = {}) {
-	const session = options.session;
-	const groupCols = normalizeGroupBy(req.groupBy);
-	if (req.having) {
-		const { pipeline, prePaginationIndex } = buildAggPipeline(req);
-		const finalPipeline = [...pipeline.slice(0, prePaginationIndex), { $count: "n" }];
-		const aggregation = Model.aggregate(finalPipeline);
-		if (session) aggregation.session(session);
-		const [row] = await aggregation.exec();
-		return row?.n ?? 0;
-	}
-	const match = req.filter ? compileFilterToMongo(req.filter) : {};
-	if (groupCols.length === 0) {
-		const pipeline = [];
-		if (Object.keys(match).length > 0) pipeline.push({ $match: match });
-		pipeline.push({ $limit: 1 });
-		pipeline.push({ $count: "n" });
-		const aggregation = Model.aggregate(pipeline);
-		if (session) aggregation.session(session);
-		const [row] = await aggregation.exec();
-		return row?.n ?? 0;
-	}
-	const groupId = groupCols.reduce((acc, field) => {
-		acc[field] = `$${field}`;
-		return acc;
-	}, {});
-	const pipeline = [];
-	if (Object.keys(match).length > 0) pipeline.push({ $match: match });
-	pipeline.push({ $group: { _id: groupId } });
-	pipeline.push({ $count: "n" });
-	const aggregation = Model.aggregate(pipeline);
-	if (session) aggregation.session(session);
-	const [row] = await aggregation.exec();
-	return row?.n ?? 0;
-}
-//#endregion
-//#region src/actions/aggregate-ir/execute.ts
-async function executeAgg(Model, req, options = {}) {
-	const session = options.session;
-	const { pipeline } = buildAggPipeline(req);
-	const aggregation = Model.aggregate(pipeline);
-	if (session) aggregation.session(session);
-	return await aggregation.exec();
-}
-//#endregion
-//#region src/query/AggregationBuilder.ts
-/**
-* Normalize SortSpec to MongoDB's strict format (1 | -1)
-* Converts 'asc' -> 1, 'desc' -> -1
-*/
-function normalizeSortSpec(sortSpec) {
-	const normalized = {};
-	for (const [field, order] of Object.entries(sortSpec)) if (order === "asc") normalized[field] = 1;
-	else if (order === "desc") normalized[field] = -1;
-	else normalized[field] = order;
-	return normalized;
-}
-/**
-* Fluent builder for MongoDB aggregation pipelines
-* Optimized for complex queries at scale
-*/
-var AggregationBuilder = class AggregationBuilder {
-	pipeline = [];
-	_diskUse = false;
-	/**
-	* Get the current pipeline
-	*/
-	get() {
-		return [...this.pipeline];
-	}
-	/**
-	* Build and return the final pipeline
-	*/
-	build() {
-		return this.get();
-	}
-	/**
-	* Build pipeline with execution options (allowDiskUse, etc.)
-	*/
-	plan() {
-		return {
-			pipeline: this.get(),
-			allowDiskUse: this._diskUse
-		};
-	}
-	/**
-	* Build and execute the pipeline against a model
-	*
-	* @example
-	* ```typescript
-	* const results = await new AggregationBuilder()
-	*   .match({ status: 'active' })
-	*   .allowDiskUse()
-	*   .exec(MyModel);
-	* ```
-	*/
-	async exec(model, session) {
-		const agg = model.aggregate(this.build());
-		if (this._diskUse) agg.allowDiskUse(true);
-		if (session) agg.session(session);
-		return agg.exec();
-	}
-	/**
-	* Reset the pipeline
-	*/
-	reset() {
-		this.pipeline = [];
-		this._diskUse = false;
-		return this;
-	}
-	/**
-	* Add a raw pipeline stage
-	*/
-	addStage(stage) {
-		this.pipeline.push(stage);
-		return this;
-	}
-	/**
-	* Add multiple raw pipeline stages
-	*/
-	addStages(stages) {
-		this.pipeline.push(...stages);
-		return this;
-	}
-	/**
-	* $match - Filter documents
-	* IMPORTANT: Place $match as early as possible for performance
-	*/
-	match(query) {
-		this.pipeline.push({ $match: query });
-		return this;
-	}
-	/**
-	* $project - Include/exclude fields or compute new fields
-	*/
-	project(projection) {
-		this.pipeline.push({ $project: projection });
-		return this;
-	}
-	/**
-	* $group - Group documents and compute aggregations
-	*
-	* @example
-	* ```typescript
-	* .group({
-	*   _id: '$department',
-	*   count: { $sum: 1 },
-	*   avgSalary: { $avg: '$salary' }
-	* })
-	* ```
-	*/
-	group(groupSpec) {
-		this.pipeline.push({ $group: groupSpec });
-		return this;
-	}
-	/**
-	* $sort - Sort documents
-	*/
-	sort(sortSpec) {
-		if (typeof sortSpec === "string") {
-			const order = sortSpec.startsWith("-") ? -1 : 1;
-			const field = sortSpec.startsWith("-") ? sortSpec.substring(1) : sortSpec;
-			this.pipeline.push({ $sort: { [field]: order } });
-		} else this.pipeline.push({ $sort: normalizeSortSpec(sortSpec) });
-		return this;
-	}
-	/**
-	* $limit - Limit number of documents
-	*/
-	limit(count) {
-		this.pipeline.push({ $limit: count });
-		return this;
-	}
-	/**
-	* $skip - Skip documents
-	*/
-	skip(count) {
-		this.pipeline.push({ $skip: count });
-		return this;
-	}
-	/**
-	* $unwind - Deconstruct array field
-	*/
-	unwind(path, preserveNullAndEmptyArrays = false) {
-		this.pipeline.push({ $unwind: {
-			path: path.startsWith("$") ? path : `$${path}`,
-			preserveNullAndEmptyArrays
-		} });
-		return this;
-	}
-	/**
-	* $addFields - Add new fields or replace existing fields
-	*/
-	addFields(fields) {
-		this.pipeline.push({ $addFields: fields });
-		return this;
-	}
-	/**
-	* $set - Alias for $addFields
-	*/
-	set(fields) {
-		return this.addFields(fields);
-	}
-	/**
-	* $unset - Remove fields
-	*/
-	unset(fields) {
-		this.pipeline.push({ $unset: fields });
-		return this;
-	}
-	/**
-	* $replaceRoot - Replace the root document
-	*/
-	replaceRoot(newRoot) {
-		this.pipeline.push({ $replaceRoot: { newRoot: typeof newRoot === "string" ? `$${newRoot}` : newRoot } });
-		return this;
-	}
-	/**
-	* $lookup - Join with another collection (simple form)
-	*
-	* @param from - Collection to join with
-	* @param localField - Field from source collection
-	* @param foreignField - Field from target collection
-	* @param as - Output field name
-	* @param single - Unwrap array to single object
-	*
-	* @example
-	* ```typescript
-	* // Join employees with departments by slug
-	* .lookup('departments', 'deptSlug', 'slug', 'department', true)
-	* ```
-	*/
-	lookup(from, localField, foreignField, as, single) {
-		const stages = new LookupBuilder(from).localField(localField).foreignField(foreignField).as(as || from).single(single || false).build();
-		this.pipeline.push(...stages);
-		return this;
-	}
-	/**
-	* $lookup - Join with another collection (advanced form with pipeline)
-	*
-	* @example
-	* ```typescript
-	* .lookupWithPipeline({
-	*   from: 'products',
-	*   localField: 'productIds',
-	*   foreignField: 'sku',
-	*   as: 'products',
-	*   pipeline: [
-	*     { $match: { status: 'active' } },
-	*     { $project: { name: 1, price: 1 } }
-	*   ]
-	* })
-	* ```
-	*/
-	lookupWithPipeline(options) {
-		const builder = new LookupBuilder(options.from).localField(options.localField).foreignField(options.foreignField);
-		if (options.as) builder.as(options.as);
-		if (options.single) builder.single(options.single);
-		if (options.pipeline) builder.pipeline(options.pipeline);
-		if (options.let) builder.let(options.let);
-		this.pipeline.push(...builder.build());
-		return this;
-	}
-	/**
-	* Multiple lookups at once
-	*
-	* @example
-	* ```typescript
-	* .multiLookup([
-	*   { from: 'departments', localField: 'deptSlug', foreignField: 'slug', single: true },
-	*   { from: 'managers', localField: 'managerId', foreignField: '_id', single: true }
-	* ])
-	* ```
-	*/
-	multiLookup(lookups) {
-		const stages = LookupBuilder.multiple(lookups);
-		this.pipeline.push(...stages);
-		return this;
-	}
-	/**
-	* $facet - Process multiple aggregation pipelines in a single stage
-	* Useful for computing multiple aggregations in parallel
-	*
-	* @example
-	* ```typescript
-	* .facet({
-	*   totalCount: [{ $count: 'count' }],
-	*   avgPrice: [{ $group: { _id: null, avg: { $avg: '$price' } } }],
-	*   topProducts: [{ $sort: { sales: -1 } }, { $limit: 10 }]
-	* })
-	* ```
-	*/
-	facet(facets) {
-		this.pipeline.push({ $facet: facets });
-		return this;
-	}
-	/**
-	* $bucket - Categorize documents into buckets
-	*
-	* @example
-	* ```typescript
-	* .bucket({
-	*   groupBy: '$price',
-	*   boundaries: [0, 50, 100, 200],
-	*   default: 'Other',
-	*   output: {
-	*     count: { $sum: 1 },
-	*     products: { $push: '$name' }
-	*   }
-	* })
-	* ```
-	*/
-	bucket(options) {
-		this.pipeline.push({ $bucket: options });
-		return this;
-	}
-	/**
-	* $bucketAuto - Automatically determine bucket boundaries
-	*/
-	bucketAuto(options) {
-		this.pipeline.push({ $bucketAuto: options });
-		return this;
-	}
-	/**
-	* $setWindowFields - Perform window functions (MongoDB 5.0+)
-	* Useful for rankings, running totals, moving averages
-	*
-	* @example
-	* ```typescript
-	* .setWindowFields({
-	*   partitionBy: '$department',
-	*   sortBy: { salary: -1 },
-	*   output: {
-	*     rank: { $rank: {} },
-	*     runningTotal: { $sum: '$salary', window: { documents: ['unbounded', 'current'] } }
-	*   }
-	* })
-	* ```
-	*/
-	setWindowFields(options) {
-		const normalizedOptions = {
-			...options,
-			sortBy: options.sortBy ? normalizeSortSpec(options.sortBy) : void 0
-		};
-		this.pipeline.push({ $setWindowFields: normalizedOptions });
-		return this;
-	}
-	/**
-	* $unionWith - Combine results from multiple collections (MongoDB 4.4+)
-	*
-	* @example
-	* ```typescript
-	* .unionWith({
-	*   coll: 'archivedOrders',
-	*   pipeline: [{ $match: { year: 2024 } }]
-	* })
-	* ```
-	*/
-	unionWith(options) {
-		this.pipeline.push({ $unionWith: options });
-		return this;
-	}
-	/**
-	* $densify - Fill gaps in data (MongoDB 5.1+)
-	* Useful for time series data with missing points
-	*/
-	densify(options) {
-		this.pipeline.push({ $densify: options });
-		return this;
-	}
-	/**
-	* $fill - Fill null or missing field values (MongoDB 5.3+)
-	*/
-	fill(options) {
-		const normalizedOptions = {
-			...options,
-			sortBy: options.sortBy ? normalizeSortSpec(options.sortBy) : void 0
-		};
-		this.pipeline.push({ $fill: normalizedOptions });
-		return this;
-	}
-	/**
-	* Enable allowDiskUse for large aggregations that exceed 100MB memory limit
-	*
-	* @example
-	* ```typescript
-	* const results = await new AggregationBuilder()
-	*   .match({ status: 'active' })
-	*   .group({ _id: '$category', total: { $sum: '$amount' } })
-	*   .allowDiskUse()
-	*   .exec(Model);
-	* ```
-	*/
-	allowDiskUse(enable = true) {
-		this._diskUse = enable;
-		return this;
-	}
-	/**
-	* Paginate - Add skip and limit for offset-based pagination
-	*/
-	paginate(page, limit) {
-		const skip = (page - 1) * limit;
-		return this.skip(skip).limit(limit);
-	}
-	/**
-	* Count total documents (useful with $facet for pagination metadata)
-	*/
-	count(outputField = "count") {
-		this.pipeline.push({ $count: outputField });
-		return this;
-	}
-	/**
-	* Sample - Randomly select N documents
-	*/
-	sample(size) {
-		this.pipeline.push({ $sample: { size } });
-		return this;
-	}
-	/**
-	* Out - Write results to a collection
-	*/
-	out(collection) {
-		this.pipeline.push({ $out: collection });
-		return this;
-	}
-	/**
-	* Merge - Merge results into a collection
-	*/
-	merge(options) {
-		this.pipeline.push({ $merge: typeof options === "string" ? { into: options } : options });
-		return this;
-	}
-	/**
-	* GeoNear - Perform geospatial queries
-	*/
-	geoNear(options) {
-		this.pipeline.push({ $geoNear: options });
-		return this;
-	}
-	/**
-	* GraphLookup - Perform recursive search (graph traversal)
-	*/
-	graphLookup(options) {
-		this.pipeline.push({ $graphLookup: options });
-		return this;
-	}
-	/**
-	* $search - Atlas Search full-text search (Atlas only)
-	*
-	* @example
-	* ```typescript
-	* .search({
-	*   index: 'default',
-	*   text: {
-	*     query: 'laptop computer',
-	*     path: ['title', 'description'],
-	*     fuzzy: { maxEdits: 2 }
-	*   }
-	* })
-	* ```
-	*/
-	search(options) {
-		this.pipeline.push({ $search: options });
-		return this;
-	}
-	/**
-	* $searchMeta - Get Atlas Search metadata (Atlas only)
-	*/
-	searchMeta(options) {
-		this.pipeline.push({ $searchMeta: options });
-		return this;
-	}
-	/**
-	* $vectorSearch - Semantic similarity search using vector embeddings (Atlas only)
-	*
-	* Requires an Atlas Vector Search index on the target field.
-	* Must be the first stage in the pipeline.
-	*
-	* @example
-	* ```typescript
-	* const results = await new AggregationBuilder()
-	*   .vectorSearch({
-	*     index: 'vector_index',
-	*     path: 'embedding',
-	*     queryVector: await getEmbedding('running shoes'),
-	*     limit: 10,
-	*     numCandidates: 100,
-	*     filter: { category: 'footwear' }
-	*   })
-	*   .project({ embedding: 0, score: { $meta: 'vectorSearchScore' } })
-	*   .exec(ProductModel);
-	* ```
-	*/
-	vectorSearch(options) {
-		if (this.pipeline.length > 0) throw new Error("[mongokit] $vectorSearch must be the first stage in the pipeline");
-		const rawCandidates = options.numCandidates ?? Math.max(options.limit * 10, 100);
-		const numCandidates = Math.min(Math.max(rawCandidates, options.limit), 1e4);
-		this.pipeline.push({ $vectorSearch: {
-			index: options.index,
-			path: options.path,
-			queryVector: options.queryVector,
-			numCandidates,
-			limit: options.limit,
-			...options.filter && { filter: options.filter },
-			...options.exact && { exact: options.exact }
-		} });
-		return this;
-	}
-	/**
-	* Add vectorSearchScore as a field after $vectorSearch
-	* Convenience for `.addFields({ score: { $meta: 'vectorSearchScore' } })`
-	*/
-	withVectorScore(fieldName = "score") {
-		return this.addFields({ [fieldName]: { $meta: "vectorSearchScore" } });
-	}
-	/**
-	* Create a builder from an existing pipeline
-	*/
-	static from(pipeline) {
-		const builder = new AggregationBuilder();
-		builder.pipeline = [...pipeline];
-		return builder;
-	}
-	/**
-	* Create a builder with initial match stage
-	*/
-	static startWith(query) {
-		return new AggregationBuilder().match(query);
-	}
-};
-/**
-* Optimized Aggregation Patterns for Scale
-*
-* 1. **Early Filtering** - Always place $match as early as possible:
-*    ```typescript
-*    new AggregationBuilder()
-*      .match({ status: 'active' })  // ✅ Filter first
-*      .lookup(...)                  // Then join
-*      .sort(...)
-*    ```
-*
-* 2. **Index Usage** - Ensure indexes on:
-*    - Fields in $match
-*    - Fields in $sort (especially with $limit)
-*    - Fields in $lookup (both local and foreign)
-*
-* 3. **Projection** - Remove unnecessary fields early:
-*    ```typescript
-*    .project({ password: 0, internalNotes: 0 })  // Remove before joins
-*    .lookup(...)
-*    ```
-*
-* 4. **Faceted Pagination** - Get count and data in one query:
-*    ```typescript
-*    .facet({
-*      metadata: [{ $count: 'total' }],
-*      data: [{ $skip: skip }, { $limit: limit }]
-*    })
-*    ```
-*
-* 5. **allowDiskUse** - For large datasets:
-*    ```typescript
-*    new AggregationBuilder()
-*      .match({ status: 'active' })
-*      .allowDiskUse()
-*      .exec(Model)
-*    ```
-*
-* 6. **Vector Search** - Semantic similarity (Atlas only):
-*    ```typescript
-*    new AggregationBuilder()
-*      .vectorSearch({ index: 'vec_idx', path: 'embedding', queryVector: vec, limit: 10 })
-*      .withVectorScore()
-*      .exec(Model)
-*    ```
-*/
-//#endregion
-//#region src/transaction.ts
-/**
-* Run a callback inside a MongoDB transaction on the given connection.
-*
-* - Starts a session, runs `session.withTransaction(callback)` (which auto-retries
-*   on `TransientTransactionError` and `UnknownTransactionCommitResult`), and
-*   always ends the session in `finally`.
-* - When `allowFallback` is true and the deployment doesn't support transactions
-*   (e.g. standalone MongoDB in dev), the callback runs once without a
-*   transaction on the same session. `onFallback` is invoked with the original
-*   error so hosts can log the degradation.
-*
-* @example
-* ```ts
-* import mongoose from 'mongoose';
-* import { withTransaction } from '@classytic/mongokit';
-*
-* await withTransaction(mongoose.connection, async (session) => {
-*   const order  = await orderRepo.create(data, { session });
-*   await inventoryRepo.decrement(order.items, { session });
-*   return order;
-* });
-* ```
-*/
-async function withTransaction(connection, callback, options = {}) {
-	const session = await connection.startSession();
-	try {
-		return await session.withTransaction(() => callback(session), options.transactionOptions);
-	} catch (error) {
-		const err = error;
-		if (options.allowFallback && isTransactionUnsupported(err)) {
-			options.onFallback?.(err);
-			return await callback(session);
-		}
-		throw err;
-	} finally {
-		await session.endSession();
-	}
-}
-/**
-* Detect whether an error indicates the MongoDB deployment does not support
-* multi-document transactions (standalone server, older topology, etc.).
-*
-* Checks MongoDB error codes first — 263 (standalone) and 20 (unsupported
-* topology) — with a message-matching fallback for edge cases surfaced by
-* older driver versions.
-*/
-function isTransactionUnsupported(error) {
-	const code = error.code;
-	if (code === 263 || code === 20) return true;
-	const message = (error.message || "").toLowerCase();
-	return message.includes("transaction numbers are only allowed on a replica set member") || message.includes("transaction is not supported");
-}
-//#endregion
-//#region src/tx-bound.ts
-/**
-* Map of session-aware method name → positional index of the `{ session }`
-* options bag. Keep this list in sync with the method signatures in
-* `Repository.ts` and the plugin method definitions. Unknown plugin
-* methods pass through unwrapped (callers use the standalone helper).
-*/
-const SESSION_OPTIONS_INDEX = Object.freeze({
-	create: 1,
-	update: 2,
-	delete: 1,
-	getById: 1,
-	getAll: 1,
-	createMany: 1,
-	findAll: 1,
-	getOrCreate: 2,
-	count: 1,
-	exists: 1,
-	getByQuery: 1,
-	getOne: 1,
-	findOneAndUpdate: 2,
-	distinct: 2,
-	aggregate: 1,
-	aggregatePaginate: 0,
-	lookupPopulate: 0,
-	upsert: 2,
-	increment: 3,
-	decrement: 3,
-	multiplyField: 3,
-	setMin: 3,
-	setMax: 3,
-	pushToArray: 3,
-	pullFromArray: 3,
-	addToSet: 3,
-	setField: 3,
-	unsetField: 2,
-	renameField: 3,
-	atomicUpdate: 2,
-	updateMany: 2,
-	deleteMany: 1,
-	bulkWrite: 1,
-	restore: 1,
-	getDeleted: 1,
-	addSubdocument: 3,
-	getSubdocument: 3,
-	updateSubdocument: 4,
-	deleteSubdocument: 3,
-	groupBy: 1,
-	sum: 2,
-	average: 2,
-	min: 2,
-	max: 2
-});
-/**
-* Build a session-threaded proxy over `outer`. The returned object has the
-* same method signatures, but every CRUD call auto-injects the supplied
-* session into the options bag. Non-CRUD properties (Model, modelName,
-* hook API, utility helpers) pass through.
-*/
-function createTxBoundRepo(outer, session) {
-	return new Proxy(outer, { get(target, prop, receiver) {
-		if (prop === "withTransaction") return () => {
-			throw new Error("[mongokit] Nested withTransaction is not supported on a tx-bound repository. Reuse the outer `txRepo` directly, or collapse the nesting.");
-		};
-		const value = Reflect.get(target, prop, receiver);
-		if (typeof value !== "function") return value;
-		if (typeof prop === "symbol") return value.bind(target);
-		if (prop.startsWith("_")) return value.bind(target);
-		const optionsIndex = SESSION_OPTIONS_INDEX[prop];
-		if (optionsIndex === void 0) return value.bind(target);
-		return function txBoundMethod(...args) {
-			while (args.length <= optionsIndex) args.push(void 0);
-			const current = args[optionsIndex];
-			if (current === void 0) args[optionsIndex] = { session };
-			else if (typeof current === "object" && current !== null && !Array.isArray(current)) args[optionsIndex] = {
-				...current,
-				session
-			};
-			else return value.apply(target, args);
-			return value.apply(target, args);
-		};
-	} });
-}
-//#endregion
-//#region src/Repository.ts
-function ensureLookupProjectionIncludesCursorFields(projection, sort) {
-	if (!projection || !sort) return projection;
-	if (!Object.values(projection).some((value) => value === 1)) return projection;
-	const nextProjection = { ...projection };
-	for (const field of [...Object.keys(sort), "_id"]) nextProjection[field] = 1;
-	return nextProjection;
-}
-/**
-* Plugin phase priorities (lower = runs first).
-*
-* Re-exported from `@classytic/repo-core/hooks` so mongokit 3.10 callers see
-* the same constant whether they import from mongokit or directly from
-* repo-core — priorities are identical (POLICY=100, CACHE=200,
-* OBSERVABILITY=300, DEFAULT=500) and the two refs are reference-equal.
-*/
-const HOOK_PRIORITY$1 = HOOK_PRIORITY;
-/**
-* Production-grade repository for MongoDB.
-*
-* Extends `@classytic/repo-core/repository`'s `RepositoryBase` for the
-* driver-agnostic hook + plugin plumbing (context builder, priority-sorted
-* event engine, plugin-order validator) while layering every Mongo-specific
-* concern — populate, aggregate, lookup, keyset + cursor pagination, $near
-* rewriting — on top.
-*
-* Public surface is byte-stable with mongokit 3.9 (the `_hooks` property is
-* preserved as a live read-through getter; all CRUD, event, and plugin method
-* signatures unchanged). 3.10 is an internal re-plumbing release; consumers
-* upgrading from 3.9 need no code changes.
-*/
-var Repository = class extends RepositoryBase {
-	Model;
-	/**
-	* Mongoose model name. Duplicated on the instance for BC — arc / catalog /
-	* user code read `repo.model`. `RepositoryBase.modelName` points to the
-	* same string; prefer `modelName` in new code.
-	*/
-	model;
-	_pagination;
-	idField;
-	searchMode;
-	searchFields;
-	_hasTextIndex = null;
-	constructor(Model, plugins = [], paginationConfig = {}, options = {}) {
-		super({
-			name: Model.modelName,
-			hooks: options.hooks ?? "async",
-			pluginOrderChecks: "off"
-		});
-		validatePluginOrder(plugins, Model.modelName, options.pluginOrderChecks ?? "warn", (m) => {
-			warn(m);
-		});
-		this.Model = Model;
-		this.model = Model.modelName;
-		this._pagination = new PaginationEngine(Model, paginationConfig);
-		this.idField = options.idField ?? "_id";
-		this.searchMode = options.searchMode ?? "text";
-		this.searchFields = options.searchFields;
-		if (this.searchMode === "regex" && (!this.searchFields || this.searchFields.length === 0)) warn(`[mongokit] Repository "${this.model}" configured with searchMode: 'regex' but no searchFields provided. getAll({ search }) will throw until searchFields is set.`);
-		for (const plugin of plugins) this.use(plugin);
-	}
-	/**
-	* Live read-through view of the hook engine's listener registry.
-	*
-	* Preserved as a public field on the Repository for back-compat with
-	* mongokit ≤3.9 — existing tests and observability code pattern-match
-	* `repo._hooks.get('before:getAll')` / `repo._hooks.size`. Each access
-	* returns a fresh snapshot of the underlying HookEngine state.
-	*
-	* Read-only. To register listeners use `repo.on(event, listener, { priority })`.
-	*/
-	get _hooks() {
-		return this.hooks.listeners();
-	}
-	/**
-	* Fire-and-forget emit aliased through RepositoryBase's async path so
-	* error hooks converted to/from sync mode still route uniformly. Mongokit
-	* ≤3.9 made this a private method on its subclass; the base class exposes
-	* it publicly and wraps it in `_emitHook` below for internal use.
-	*/
-	async _emitHook(event, data) {
-		await this.hooks.emitAccordingToMode(event, data);
-	}
-	async _emitErrorHook(event, data) {
-		try {
-			await this._emitHook(event, data);
-		} catch (hookError) {
-			warn(`[${this.model}] Error hook '${event}' threw: ${hookError instanceof Error ? hookError.message : String(hookError)}`);
-		}
-	}
-	/**
-	* Run a Repository operation under the standard envelope:
-	*   - invoke `fn`, emit `after:<op>` with `{ context, result }` on success
-	*   - emit `error:<op>` and rethrow via `_handleError` on failure
-	*
-	* Methods with branched in-try logic that emit `after:*` from multiple
-	* paths (`getById`, `update`, `delete`, `deleteMany`, `aggregatePaginate`,
-	* `lookupPopulate`) intentionally keep their inline try/catch rather than
-	* being restructured to return a single result through this helper.
-	*/
-	async _runOp(op, context, fn) {
-		try {
-			const result = await fn();
-			await this._emitHook(`after:${op}`, {
-				context,
-				result
-			});
-			return result;
-		} catch (error) {
-			await this._emitErrorHook(`error:${op}`, {
-				context,
-				error
-			});
-			throw this._handleError(error);
-		}
-	}
-	/**
-	* Create single document
-	*/
-	async create(data, options = {}) {
-		const context = await this._buildContext("create", {
-			data,
-			...options
-		});
-		return this._runOp("create", context, () => create(this.Model, context.data || data, options));
-	}
-	/**
-	* Create multiple documents
-	*/
-	async createMany(dataArray, options = {}) {
-		const context = await this._buildContext("createMany", {
-			dataArray,
-			...options
-		});
-		return this._runOp("createMany", context, () => createMany(this.Model, context.dataArray || dataArray, options));
-	}
-	/**
-	* Get document by ID
-	*/
-	async getById(id, options = {}) {
-		const populateSpec = options.populateOptions || options.populate;
-		const context = await this._buildContext("getById", {
-			id,
-			...options,
-			populate: populateSpec
-		});
-		if (context._cacheHit) {
-			const cachedResult = context._cachedResult;
-			await this._emitHook("after:getById", {
-				context,
-				result: cachedResult,
-				fromCache: true
-			});
-			return cachedResult;
-		}
-		try {
-			const effectiveIdField = options.idField ?? this.idField;
-			if (effectiveIdField !== "_id") {
-				const result = await getByQuery(this.Model, {
-					[effectiveIdField]: id,
-					...context.query || {}
-				}, context);
-				await this._emitHook("after:getById", {
-					context,
-					result
-				});
-				return result;
-			}
-			const wantsThrow = context.throwOnNotFound === true || options.throwOnNotFound === true;
-			if (!isValidIdForType(id, getSchemaIdType(this.Model.schema))) {
-				if (wantsThrow) throw createError(404, "Document not found");
-				return null;
-			}
-			const result = await getById(this.Model, id, context);
-			if (!result && wantsThrow) throw createError(404, "Document not found");
-			await this._emitHook("after:getById", {
-				context,
-				result
-			});
-			return result;
-		} catch (error) {
-			await this._emitErrorHook("error:getById", {
-				context,
-				error
-			});
-			throw this._handleError(error);
-		}
-	}
-	/**
-	* Get single document by query
-	*/
-	async getByQuery(query, options = {}) {
-		const populateSpec = options.populateOptions || options.populate;
-		const context = await this._buildContext("getByQuery", {
-			query,
-			...options,
-			populate: populateSpec
-		});
-		if (context._cacheHit) {
-			const cachedResult = context._cachedResult;
-			await this._emitHook("after:getByQuery", {
-				context,
-				result: cachedResult,
-				fromCache: true
-			});
-			return cachedResult;
-		}
-		const finalQuery = context.query || query;
-		return this._runOp("getByQuery", context, () => getByQuery(this.Model, finalQuery, context));
-	}
-	/**
-	* Get single document by arbitrary filter.
-	* Unlike getByQuery, this method is designed for Arc/controller use where
-	* compound filters (org scope + policy + id) are pre-built.
-	*
-	* @example
-	* const product = await repo.getOne({ slug: 'laptop', organizationId: 'org_1' });
-	*/
-	async getOne(query, options = {}) {
-		const populateSpec = options.populateOptions || options.populate;
-		const context = await this._buildContext("getOne", {
-			query,
-			...options,
-			populate: populateSpec
-		});
-		if (context._cacheHit) {
-			const cachedResult = context._cachedResult;
-			await this._emitHook("after:getOne", {
-				context,
-				result: cachedResult,
-				fromCache: true
-			});
-			return cachedResult;
-		}
-		const finalQuery = context.query || query;
-		return this._runOp("getOne", context, () => getByQuery(this.Model, finalQuery, context));
-	}
-	/**
-	* Fetch ALL documents matching filters without pagination.
-	* Use for background jobs, exports, batch processing where you need every doc.
-	*
-	* @example
-	* const all = await repo.findAll({ status: 'active' });
-	* const allLean = await repo.findAll({}, { select: 'name email', lean: true });
-	*/
-	async findAll(filters = {}, options = {}) {
-		const context = await this._buildContext("findAll", {
-			query: filters,
-			...options
-		});
-		const resolvedFilters = context.query ?? filters;
-		return this._runOp("findAll", context, async () => {
-			const query = this.Model.find(resolvedFilters);
-			const sortSpec = context.sort || options.sort;
-			if (sortSpec) query.sort(this._parseSort(sortSpec));
-			const selectSpec = context.select || options.select;
-			if (selectSpec) query.select(selectSpec);
-			if (options.populate || context.populate) query.populate(this._parsePopulate(context.populate || options.populate));
-			if (context.lean ?? options.lean ?? true) query.lean();
-			if (options.session) query.session(options.session);
-			if (options.readPreference) query.read(options.readPreference);
-			return await query.exec();
-		});
-	}
-	/**
-	* Unified pagination - auto-detects offset vs keyset based on params
-	*
-	* Auto-detection logic:
-	* - If params has 'cursor' or 'after' → uses keyset pagination (stream)
-	* - If params has 'pagination' or 'page' → uses offset pagination (paginate)
-	* - Else → defaults to offset pagination with page=1
-	*
-	* @example
-	* // Offset pagination (page-based)
-	* await repo.getAll({ page: 1, limit: 50, filters: { status: 'active' } });
-	* await repo.getAll({ pagination: { page: 2, limit: 20 } });
-	*
-	* // Keyset pagination (cursor-based)
-	* await repo.getAll({ cursor: 'eyJ2Ij...', limit: 50 });
-	* await repo.getAll({ after: 'eyJ2Ij...', sort: { createdAt: -1 } });
-	*
-	* // Simple query (defaults to page 1)
-	* await repo.getAll({ filters: { status: 'active' } });
-	*
-	* // Skip cache for fresh data
-	* await repo.getAll({ filters: { status: 'active' } }, { skipCache: true });
-	*/
-	async getAll(params = {}, options = {}) {
-		const normalizedParams = {
-			...params,
-			page: params.page ?? params.pagination?.page,
-			limit: params.limit ?? params.pagination?.limit
-		};
-		const context = await this._buildContext("getAll", {
-			...normalizedParams,
-			...options
-		});
-		if (context._cacheHit) {
-			const cachedResult = context._cachedResult;
-			await this._emitHook("after:getAll", {
-				context,
-				result: cachedResult,
-				fromCache: true
-			});
-			return cachedResult;
-		}
-		if (params.noPagination) return this.findAll(context.filters ?? params.filters ?? {}, {
-			...options,
-			sort: context.sort ?? params.sort
-		});
-		const filters = context.filters ?? params.filters ?? {};
-		const search = context.search;
-		const isNearQuery = hasNearOperator(filters);
-		const sort = this._resolveSort(context, params, isNearQuery);
-		const limit = context.limit ?? params.limit ?? params.pagination?.limit ?? this._pagination.config.defaultLimit;
-		const page = context.page ?? params.pagination?.page ?? params.page;
-		const after = context.after ?? params.cursor ?? params.after;
-		const mode = context.mode ?? params.mode;
-		const useKeyset = this._detectPaginationMode(mode, page, after, sort, context, params);
-		const query = this._buildSearchQuery(filters, search);
-		const populateSpec = options.populateOptions || params.populateOptions || context.populate || options.populate;
-		const paginationOptions = {
-			filters: query,
-			sort: isNearQuery ? void 0 : this._parseSort(sort),
-			limit,
-			populate: this._parsePopulate(populateSpec),
-			select: context.select || options.select,
-			lean: context.lean ?? options.lean ?? true,
-			session: options.session,
-			hint: context.hint ?? params.hint,
-			maxTimeMS: context.maxTimeMS ?? params.maxTimeMS,
-			readPreference: context.readPreference ?? options.readPreference ?? params.readPreference,
-			collation: context.collation ?? params.collation
-		};
-		const lookups = context.lookups ?? params.lookups;
-		if (lookups && lookups.length > 0) return this._runOp("getAll", context, async () => {
-			return await this.lookupPopulate({
-				filters: query,
-				lookups,
-				sort: paginationOptions.sort,
-				page: useKeyset ? void 0 : page || 1,
-				after: useKeyset ? after : void 0,
-				limit,
-				select: paginationOptions.select,
-				session: options.session,
-				readPreference: paginationOptions.readPreference,
-				collation: paginationOptions.collation,
-				countStrategy: context.countStrategy ?? params.countStrategy
-			});
-		});
-		return this._runOp("getAll", context, async () => {
-			let result;
-			if (useKeyset) result = await this._pagination.stream({
-				...paginationOptions,
-				sort: paginationOptions.sort,
-				after
-			});
-			else {
-				let countFilters;
-				let forcedCountStrategy;
-				if (isNearQuery) {
-					const rewritten = rewriteNearForCount(query);
-					if (rewritten) countFilters = rewritten;
-					else forcedCountStrategy = "none";
-				}
-				result = await this._pagination.paginate({
-					...paginationOptions,
-					page: page || 1,
-					countFilters,
-					countStrategy: context.countStrategy ?? params.countStrategy ?? forcedCountStrategy
-				});
-			}
-			return result;
-		});
-	}
-	/**
-	* Get or create document
-	* Routes through hook system for policy enforcement (multi-tenant, soft-delete)
-	*/
-	async getOrCreate(query, createData, options = {}) {
-		const context = await this._buildContext("getOrCreate", {
-			query,
-			data: createData,
-			...options
-		});
-		return this._runOp("getOrCreate", context, () => {
-			const finalQuery = context.query || query;
-			const finalData = context.data || createData;
-			return getOrCreate(this.Model, finalQuery, finalData, options);
-		});
-	}
-	/**
-	* Count documents
-	* Routes through hook system for policy enforcement (multi-tenant, soft-delete)
-	*/
-	async count(query = {}, options = {}) {
-		const context = await this._buildContext("count", {
-			query,
-			...options
-		});
-		return this._runOp("count", context, () => count(this.Model, context.query || query, options));
-	}
-	/**
-	* Check if document exists
-	* Routes through hook system for policy enforcement (multi-tenant, soft-delete)
-	*/
-	async exists(query, options = {}) {
-		const context = await this._buildContext("exists", {
-			query,
-			...options
-		});
-		return this._runOp("exists", context, () => exists(this.Model, context.query || query, options));
-	}
-	/**
-	* Update document by ID
-	*/
-	async update(id, data, options = {}) {
-		const context = await this._buildContext("update", {
-			id,
-			data,
-			...options
-		});
-		try {
-			const wantsThrow = context.throwOnNotFound === true || options.throwOnNotFound === true;
-			const effectiveIdField = options.idField ?? this.idField;
-			if (effectiveIdField === "_id") {
-				if (!isValidIdForType(id, getSchemaIdType(this.Model.schema))) {
-					if (wantsThrow) throw createError(404, "Document not found");
-					await this._emitHook("after:update", {
-						context,
-						result: null
-					});
-					return null;
-				}
-			}
-			let result;
-			if (effectiveIdField !== "_id") result = await updateByQuery(this.Model, {
-				[effectiveIdField]: id,
-				...context.query || {}
-			}, context.data || data, context);
-			else result = await update(this.Model, id, context.data || data, context);
-			if (!result && wantsThrow) throw createError(404, "Document not found");
-			await this._emitHook("after:update", {
-				context,
-				result
-			});
-			return result;
-		} catch (error) {
-			await this._emitErrorHook("error:update", {
-				context,
-				error
-			});
-			throw this._handleError(error);
-		}
-	}
-	/**
-	* Atomic findOneAndUpdate (compare-and-set primitive).
-	*
-	* Single round-trip match-and-mutate for outbox relays, distributed locks,
-	* and workflow semaphores. Goes through the full hook pipeline so
-	* multi-tenant scope, soft-delete, audit, and cache plugins all apply.
-	*
-	* Returns the matched document (post-update by default) or `null` when no
-	* document matches and `upsert` is false.
-	*
-	* @example FIFO claim-lease for an outbox worker
-	* ```ts
-	* const claimed = await outboxRepo.findOneAndUpdate(
-	*   { status: 'pending', leaseExpiresAt: { $lt: new Date() } },
-	*   { $set: { status: 'processing', leaseExpiresAt: leaseUntil, leasedBy: workerId } },
-	*   { sort: { createdAt: 1 }, returnDocument: 'after' },
-	* );
-	* if (!claimed) return; // queue empty
-	* ```
-	*
-	* @example CAS upsert
-	* ```ts
-	* const lock = await locksRepo.findOneAndUpdate(
-	*   { _id: lockKey, ownerId: { $in: [null, workerId] } },
-	*   { $set: { ownerId: workerId, expiresAt: leaseUntil } },
-	*   { upsert: true },
-	* );
-	* ```
-	*/
-	async findOneAndUpdate(filter, update, options = {}) {
-		const normalizedUpdate = isUpdateSpec(update) ? compileUpdateSpecToMongo(update) : update;
-		const context = await this._buildContext("findOneAndUpdate", {
-			query: filter,
-			data: normalizedUpdate,
-			...options
-		});
-		return this._runOp("findOneAndUpdate", context, async () => {
-			const finalQuery = context.query || filter;
-			const finalUpdate = context.data || normalizedUpdate;
-			return await findOneAndUpdate(this.Model, finalQuery, finalUpdate, {
-				...options,
-				sort: options.sort,
-				returnDocument: options.returnDocument ?? "after",
-				upsert: options.upsert ?? false,
-				session: options.session
-			});
-		});
-	}
-	/**
-	* Delete a document by ID.
-	*
-	* By default the behavior is decided by the plugin stack:
-	*   - With `softDeletePlugin` wired → soft delete (sets `deletedAt`)
-	*   - Without the plugin → physical delete
-	*
-	* Pass `mode: 'hard'` to force physical deletion regardless of plugins.
-	* All policy hooks (multi-tenant scope, audit trails, cache invalidation,
-	* cascade) still fire — only the soft-delete interception is skipped. This
-	* is the GDPR / admin-cleanup path.
-	*
-	* @example
-	* ```ts
-	* // Respects softDeletePlugin — soft if wired
-	* await userRepo.delete(userId);
-	*
-	* // GDPR erasure — physical delete, audit hooks still fire
-	* await userRepo.delete(userId, { mode: 'hard', organizationId: 'org_123' });
-	* ```
-	*/
-	async delete(id, options = {}) {
-		const context = await this._buildContext("delete", {
-			id,
-			...options,
-			...options.mode ? { deleteMode: options.mode } : {}
-		});
-		try {
-			if (context.softDeleted) {
-				const result = {
-					success: true,
-					message: "Soft deleted successfully",
-					id: String(id),
-					soft: true
-				};
-				await this._emitHook("after:delete", {
-					context,
-					result
-				});
-				return result;
-			}
-			const effectiveIdField = options.idField ?? this.idField;
-			const wantsThrow = context.throwOnNotFound === true || options.throwOnNotFound === true;
-			if (effectiveIdField === "_id") {
-				if (!isValidIdForType(id, getSchemaIdType(this.Model.schema))) {
-					if (wantsThrow) throw createError(404, "Document not found");
-					const result = {
-						success: false,
-						message: "Document not found",
-						id: String(id)
-					};
-					await this._emitHook("after:delete", {
-						context,
-						result
-					});
-					return result;
-				}
-			}
-			const deleteQuery = effectiveIdField !== "_id" ? {
-				[effectiveIdField]: id,
-				...context.query || {}
-			} : void 0;
-			const result = deleteQuery ? await deleteByQuery(this.Model, deleteQuery, { session: options.session }) : await deleteById(this.Model, id, {
-				session: options.session,
-				query: context.query
-			});
-			if (!result.success && wantsThrow) throw createError(404, "Document not found");
-			await this._emitHook("after:delete", {
-				context,
-				result
-			});
-			return result;
-		} catch (error) {
-			await this._emitErrorHook("error:delete", {
-				context,
-				error
-			});
-			throw this._handleError(error);
-		}
-	}
-	/**
-	* Update every document matching the filter.
-	*
-	* Promoted from `batchOperationsPlugin` to a class primitive in 3.11.0 so
-	* the surface matches sqlitekit's always-available `updateMany`. Consumers
-	* who forget to wire `batchOperationsPlugin` no longer get a runtime
-	* `TypeError: repo.updateMany is not a function` — the method is always
-	* here.
-	*
-	* Accepts three `update` forms via `UpdateInput`:
-	*   - Portable `UpdateSpec` from `@classytic/repo-core/update` (compiled to
-	*     `$set`/`$unset`/`$inc`/`$setOnInsert` before hooks run).
-	*   - Raw Mongo operator record (`{ $set, $inc, ... }`) — passed through.
-	*   - Mongo aggregation pipeline (`[...]`) — requires `updatePipeline: true`
-	*     to guard against accidental pipeline updates.
-	*
-	* Refuses empty filters (defense-in-depth against mass-update accidents)
-	* both before and after policy hooks inject tenant scope.
-	*/
-	async updateMany(filter, update, options = {}) {
-		const normalizedData = isUpdateSpec(update) ? compileUpdateSpecToMongo(update) : update;
-		const context = await this._buildContext("updateMany", {
-			query: filter,
-			data: normalizedData,
-			...options
-		});
-		return this._runOp("updateMany", context, async () => {
-			const finalQuery = context.query || filter;
-			if (!finalQuery || Object.keys(finalQuery).length === 0) throw createError(400, "updateMany requires a non-empty query filter. Pass an explicit filter to prevent accidental mass updates.");
-			if (Array.isArray(normalizedData) && options.updatePipeline !== true) throw createError(400, "Update pipelines (array updates) are disabled by default; pass `{ updatePipeline: true }` to explicitly allow pipeline-style updates.");
-			const finalData = context.data || normalizedData;
-			return await this.Model.updateMany(finalQuery, finalData, {
-				runValidators: true,
-				session: options.session,
-				...options.updatePipeline !== void 0 ? { updatePipeline: options.updatePipeline } : {}
-			}).exec();
-		});
-	}
-	/**
-	* Delete every document matching the filter.
-	*
-	* Promoted from `batchOperationsPlugin` to a class primitive in 3.11.0 for
-	* the same reason as `updateMany` — sqlitekit parity and no silent "method
-	* is undefined" footgun when the batch plugin isn't wired.
-	*
-	* Behavior mirrors `delete()`: defaults to soft delete when
-	* `softDeletePlugin` is wired, physical delete otherwise. Pass
-	* `{ mode: 'hard' }` to bypass soft-delete — multi-tenant scoping, audit,
-	* and cache hooks still fire.
-	*
-	* Rejects empty filters up front AND after policy hooks, so a policy-plugin
-	* bug that zeroes out the query can't be exploited to wipe a collection.
-	*/
-	async deleteMany(filter, options = {}) {
-		if (!filter || Object.keys(filter).length === 0) throw createError(400, "deleteMany requires a non-empty query filter. Pass an explicit filter to prevent accidental mass deletes.");
-		const mode = options.mode;
-		const context = await this._buildContext("deleteMany", {
-			query: filter,
-			...options,
-			...mode ? { deleteMode: mode } : {}
-		});
-		try {
-			if (context.softDeleted) {
-				const result = {
-					acknowledged: true,
-					deletedCount: context.softDeletedCount ?? 0,
-					soft: true
-				};
-				await this._emitHook("after:deleteMany", {
-					context,
-					result
-				});
-				return result;
-			}
-			const finalQuery = context.query || filter;
-			if (!finalQuery || Object.keys(finalQuery).length === 0) throw createError(400, "deleteMany requires a non-empty query filter after policy hooks.");
-			const result = await this.Model.deleteMany(finalQuery, { session: options.session }).exec();
-			await this._emitHook("after:deleteMany", {
-				context,
-				result
-			});
-			return result;
-		} catch (error) {
-			await this._emitErrorHook("error:deleteMany", {
-				context,
-				error
-			});
-			throw this._handleError(error);
-		}
-	}
-	/**
-	* Kit-native aggregation pipeline — takes a MongoDB stage array and
-	* returns the raw pipeline output. Use this for `$lookup`, `$unwind`,
-	* `$facet`, `$graphLookup`, and any other mongo-specific power
-	* features that don't translate to SQL.
-	*
-	* For backend-portable aggregations (filter + group + measures +
-	* sort + limit) use `aggregate(req: AggRequest)` instead — it
-	* compiles the repo-core IR to the equivalent pipeline internally
-	* and produces the same row shape sqlitekit emits.
-	*
-	* Routes through the hook system for policy enforcement
-	* (multi-tenant, soft-delete).
-	*
-	* @param pipeline - MongoDB aggregation stage array
-	* @param options  - Aggregation options including governance controls
-	*/
-	async aggregatePipeline(pipeline, options = {}) {
-		const context = await this._buildContext("aggregatePipeline", {
-			pipeline,
-			...options
-		});
-		const maxStages = options.maxPipelineStages;
-		if (maxStages && pipeline.length > maxStages) throw createError(400, `Aggregation pipeline exceeds maximum allowed stages (${pipeline.length} > ${maxStages})`);
-		return this._runOp("aggregatePipeline", context, async () => {
-			const finalPipeline = [...pipeline];
-			if (context.query && Object.keys(context.query).length > 0) finalPipeline.unshift({ $match: context.query });
-			const aggregation = this.Model.aggregate(finalPipeline);
-			if (options.session) aggregation.session(options.session);
-			if (options.allowDiskUse) aggregation.allowDiskUse(true);
-			if (options.readPreference) aggregation.read(options.readPreference);
-			if (options.maxTimeMS) aggregation.option({ maxTimeMS: options.maxTimeMS });
-			if (options.comment) aggregation.option({ comment: options.comment });
-			if (options.readConcern) aggregation.option({ readConcern: options.readConcern });
-			if (options.collation) aggregation.collation(options.collation);
-			return await aggregation.exec();
-		});
-	}
-	/**
-	* Paginated kit-native aggregation pipeline. Same mongo-specific
-	* scope as `aggregatePipeline` — reach for this when you need
-	* `$lookup` / `$unwind` / `$facet` alongside pagination.
-	*
-	* Prefer `aggregatePaginate(req: AggPaginationRequest)` for
-	* cross-backend dashboard code; that method compiles the portable
-	* IR to an equivalent pipeline.
-	*
-	* Policy hooks (multi-tenant, soft-delete) inject context.filters
-	* which are prepended as a `$match` stage.
-	*/
-	async aggregatePipelinePaginate(options = {}) {
-		const context = await this._buildContext("aggregatePipelinePaginate", options);
-		const finalPipeline = [...context.pipeline || options.pipeline || []];
-		if (context.filters && Object.keys(context.filters).length > 0) finalPipeline.unshift({ $match: context.filters });
-		const aggOptions = {
-			...context,
-			pipeline: finalPipeline
-		};
-		return this._runOp("aggregatePipelinePaginate", context, () => this._pagination.aggregatePaginate(aggOptions));
-	}
-	/**
-	* Portable aggregation. Compiles the repo-core `AggRequest` IR to
-	* `[{$match}, {$group}, {$addFields}, {$project}, {$match}, {$sort},
-	* {$skip}, {$limit}]` against this repo's collection. Output rows
-	* carry one key per `groupBy` column plus one key per measure alias
-	* — identical shape to sqlitekit's `aggregate(req)`, so dashboards
-	* work unchanged across backends.
-	*
-	* Without `groupBy`: returns a single-row result with just the
-	* measures (scalar aggregation). Pass
-	* `{ measures: { total: { op: 'sum', field: 'amount' } } }` for a
-	* simple summary.
-	*
-	* For mongo-specific power features (`$lookup`, `$unwind`, `$facet`,
-	* `$graphLookup`, window operators) reach for `aggregatePipeline`
-	* — that's the kit-native escape hatch.
-	*
-	* Routes through the hook system for policy enforcement
-	* (multi-tenant, soft-delete) — plugins inject their scope into
-	* `context.filter`, which is merged into the pre-aggregate `$match`
-	* before compilation.
-	*/
-	async aggregate(req) {
-		const context = await this._buildContext("aggregate", { aggRequest: req });
-		return this._runOp("aggregate", context, async () => {
-			const finalReq = this._injectPolicyScopeIntoAgg(req, context);
-			return { rows: await executeAgg(this.Model, finalReq, { session: context.session }) };
-		});
-	}
-	/**
-	* Offset-paginated portable aggregation. Same IR as `aggregate`,
-	* wrapped in the standard `OffsetPaginationResultCore` envelope so
-	* UI code paginates aggregated dashboards with the same primitives
-	* as raw document lists.
-	*
-	* `countStrategy: 'none'` skips the second round-trip that computes
-	* `total`; the envelope reports `total: 0`, `pages: 0`, and derives
-	* `hasNext` from a `LIMIT N+1` peek on the data pipeline.
-	*/
-	async aggregatePaginate(req) {
-		const context = await this._buildContext("aggregatePaginate", { aggRequest: req });
-		const page = Math.max(1, req.page ?? 1);
-		const limit = Math.max(1, Math.min(req.limit ?? 20, 1e3));
-		const countStrategy = req.countStrategy ?? "exact";
-		const offset = (page - 1) * limit;
-		const session = context.session;
-		try {
-			const finalReq = this._injectPolicyScopeIntoAgg(req, context);
-			if (countStrategy === "none") {
-				const peek = await executeAgg(this.Model, {
-					...finalReq,
-					limit: limit + 1,
-					offset
-				}, session ? { session } : {});
-				const hasNext = peek.length > limit;
-				const result = {
-					method: "offset",
-					docs: hasNext ? peek.slice(0, limit) : peek,
-					page,
-					limit,
-					total: 0,
-					pages: 0,
-					hasNext,
-					hasPrev: page > 1
-				};
-				await this._emitHook("after:aggregatePaginate", {
-					context,
-					result
-				});
-				return result;
-			}
-			const [docs, total] = await Promise.all([executeAgg(this.Model, {
-				...finalReq,
-				limit,
-				offset
-			}, session ? { session } : {}), countAggGroups(this.Model, finalReq, session ? { session } : {})]);
-			const result = {
-				method: "offset",
-				docs,
-				page,
-				limit,
-				total,
-				pages: Math.max(1, Math.ceil(total / limit)),
-				hasNext: page * limit < total,
-				hasPrev: page > 1
-			};
-			await this._emitHook("after:aggregatePaginate", {
-				context,
-				result
-			});
-			return result;
-		} catch (error) {
-			await this._emitErrorHook("error:aggregatePaginate", {
-				context,
-				error
-			});
-			throw this._handleError(error);
-		}
-	}
-	/**
-	* Merge policy-hook-injected filters (multi-tenant scope,
-	* soft-delete) into the pre-aggregate `filter` slot of the request.
-	* Plugins speak mongo-query shape (`context.query` / `context.filters`);
-	* the caller's `req.filter` may be either Filter IR or a mongo query.
-	*
-	* Each part is compiled through `compileFilterToMongo` BEFORE the
-	* `$and` merge — otherwise an IR node like `eq('status', 'paid')`
-	* (`{ op, field, value }`) gets nested inside `$and` as a literal,
-	* `compileFilterToMongo` of the merged value finds no top-level `op`
-	* (so `isFilter` is false), and Mongo receives the IR object as a
-	* raw query clause that matches no real document. Symptom: aggregates
-	* silently return 0 rows whenever a callerpasses IR + a policy
-	* plugin is installed.
-	*/
-	_injectPolicyScopeIntoAgg(req, context) {
-		const scopeCandidates = [];
-		for (const candidate of [context.filters, context.query]) if (candidate && typeof candidate === "object" && Object.keys(candidate).length > 0) scopeCandidates.push(candidate);
-		if (scopeCandidates.length === 0) return req;
-		const parts = [];
-		for (const c of scopeCandidates) {
-			const compiled = compileFilterToMongo(c);
-			if (Object.keys(compiled).length > 0) parts.push(compiled);
-		}
-		if (req.filter) {
-			const compiled = compileFilterToMongo(req.filter);
-			if (Object.keys(compiled).length > 0) parts.push(compiled);
-		}
-		if (parts.length === 0) return req;
-		const merged = parts.length === 1 ? parts[0] : { $and: parts };
-		return {
-			...req,
-			filter: merged
-		};
-	}
-	/**
-	* Get distinct values
-	* Routes through hook system for policy enforcement (multi-tenant, soft-delete)
-	*/
-	async distinct(field, query = {}, options = {}) {
-		const context = await this._buildContext("distinct", {
-			query,
-			...options
-		});
-		return this._runOp("distinct", context, () => {
-			const finalQuery = context.query || query;
-			const readPreference = context.readPreference ?? options.readPreference;
-			return distinct(this.Model, field, finalQuery, {
-				session: options.session,
-				readPreference
-			});
-		});
-	}
-	/**
-	* Query with custom field lookups ($lookup)
-	* Best for: Joins on slugs, SKUs, codes, or other indexed custom fields
-	*
-	* @example
-	* ```typescript
-	* // Join employees with departments using slug instead of ObjectId
-	* const employees = await employeeRepo.lookupPopulate({
-	*   filters: { status: 'active' },
-	*   lookups: [
-	*     {
-	*       from: 'departments',
-	*       localField: 'departmentSlug',
-	*       foreignField: 'slug',
-	*       as: 'department',
-	*       single: true
-	*     }
-	*   ],
-	*   sort: '-createdAt',
-	*   page: 1,
-	*   limit: 50
-	* });
-	* ```
-	*/
-	async lookupPopulate(options) {
-		const context = await this._buildContext("lookupPopulate", options);
-		try {
-			const MAX_LOOKUPS = 10;
-			const lookups = context.lookups ?? options.lookups;
-			if (lookups.length > MAX_LOOKUPS) throw createError(400, `Too many lookups (${lookups.length}). Maximum is ${MAX_LOOKUPS}.`);
-			const filters = context.filters ?? options.filters;
-			const sort = context.sort ?? options.sort;
-			const limit = context.limit ?? options.limit ?? this._pagination.config.defaultLimit ?? 20;
-			const readPref = context.readPreference ?? options.readPreference;
-			const session = context.session ?? options.session;
-			const collation = context.collation ?? options.collation;
-			const after = context.after ?? options.after;
-			const pageFromContext = context.page ?? options.page;
-			const isKeyset = !!after || !pageFromContext && !!sort;
-			const countStrategy = context.countStrategy ?? options.countStrategy ?? "exact";
-			const selectSpec = context.select ?? options.select;
-			let projection;
-			if (selectSpec) {
-				if (typeof selectSpec === "string") {
-					projection = {};
-					for (const field of selectSpec.split(",").map((f) => f.trim())) if (field.startsWith("-")) projection[field.substring(1)] = 0;
-					else projection[field] = 1;
-				} else if (Array.isArray(selectSpec)) {
-					projection = {};
-					for (const field of selectSpec) if (field.startsWith("-")) projection[field.substring(1)] = 0;
-					else projection[field] = 1;
-				} else projection = { ...selectSpec };
-				if (projection) {
-					if (Object.values(projection).some((v) => v === 1)) for (const lookup of lookups) {
-						const asField = lookup.as || lookup.from;
-						if (!(asField in projection)) projection[asField] = 1;
-					}
-				}
-			}
-			const appendLookupStages = (pipeline) => {
-				pipeline.push(...LookupBuilder.multiple(lookups));
-				for (const lookup of lookups) if (lookup.single) {
-					const asField = lookup.as || lookup.from;
-					pipeline.push({ $addFields: { [asField]: { $ifNull: [`$${asField}`, null] } } });
-				}
-				const finalProjection = ensureLookupProjectionIncludesCursorFields(projection, isKeyset && sort ? this._parseSort(sort) : void 0);
-				if (finalProjection) pipeline.push({ $project: finalProjection });
-			};
-			if (isKeyset && sort) {
-				const parsedSort = this._parseSort(sort);
-				const { validateKeysetSort } = await import("./sort-CrZjTK25.mjs").then((n) => n.n);
-				const { encodeCursor, resolveCursorFilter } = await import("./cursor-J84rR6wG.mjs").then((n) => n.t);
-				const { getPrimaryField } = await import("./sort-CrZjTK25.mjs").then((n) => n.n);
-				const normalizedSort = validateKeysetSort(parsedSort, this._pagination.config.strictKeysetSortFields);
-				const cursorVersion = this._pagination.config.cursorVersion ?? 1;
-				const minCursorVersion = this._pagination.config.minCursorVersion ?? 1;
-				const matchFilters = after ? resolveCursorFilter(after, normalizedSort, cursorVersion, { ...filters || {} }, minCursorVersion) : { ...filters || {} };
-				if (projection) {
-					if (Object.values(projection).some((v) => v === 1)) {
-						for (const sortField of Object.keys(normalizedSort)) if (!(sortField in projection)) projection[sortField] = 1;
-					}
-				}
-				const pipeline = [];
-				if (Object.keys(matchFilters).length > 0) pipeline.push({ $match: matchFilters });
-				pipeline.push({ $sort: normalizedSort });
-				pipeline.push({ $limit: limit + 1 });
-				appendLookupStages(pipeline);
-				const aggregation = this.Model.aggregate(pipeline).session(session || null);
-				if (collation) aggregation.collation(collation);
-				if (readPref) aggregation.read(readPref);
-				const docs = await aggregation;
-				const hasMore = docs.length > limit;
-				if (hasMore) docs.pop();
-				const primaryField = getPrimaryField(normalizedSort);
-				const result = {
-					method: "keyset",
-					docs,
-					limit,
-					hasMore,
-					next: hasMore && docs.length > 0 ? encodeCursor(docs[docs.length - 1], primaryField, normalizedSort, cursorVersion) : null
-				};
-				await this._emitHook("after:lookupPopulate", {
-					context,
-					result
-				});
-				return result;
-			}
-			const page = pageFromContext ?? 1;
-			const skip = (page - 1) * limit;
-			if (skip > 1e4) warn(`[mongokit] Large offset (${skip}) in lookupPopulate. Consider using keyset pagination: getAll({ sort, after, limit, lookups })`);
-			const dataPipeline = [];
-			if (filters && Object.keys(filters).length > 0) dataPipeline.push({ $match: filters });
-			if (sort) dataPipeline.push({ $sort: this._parseSort(sort) });
-			if (countStrategy === "none") {
-				dataPipeline.push({ $skip: skip }, { $limit: limit + 1 });
-				appendLookupStages(dataPipeline);
-				const aggregation = this.Model.aggregate(dataPipeline).session(session || null);
-				if (collation) aggregation.collation(collation);
-				if (readPref) aggregation.read(readPref);
-				const docs = await aggregation;
-				const hasNext = docs.length > limit;
-				if (hasNext) docs.pop();
-				const result = {
-					method: "offset",
-					docs,
-					page,
-					limit,
-					total: 0,
-					pages: 0,
-					hasNext,
-					hasPrev: page > 1
-				};
-				await this._emitHook("after:lookupPopulate", {
-					context,
-					result
-				});
-				return result;
-			}
-			dataPipeline.push({ $skip: skip }, { $limit: limit });
-			appendLookupStages(dataPipeline);
-			const countPipeline = [];
-			if (filters && Object.keys(filters).length > 0) countPipeline.push({ $match: filters });
-			countPipeline.push({ $count: "total" });
-			const pipeline = [{ $facet: {
-				metadata: countPipeline,
-				data: dataPipeline
-			} }];
-			const aggregation = this.Model.aggregate(pipeline).session(session || null);
-			if (collation) aggregation.collation(collation);
-			if (readPref) aggregation.read(readPref);
-			const facetResult = (await aggregation)[0] || {
-				metadata: [],
-				data: []
-			};
-			const total = facetResult.metadata[0]?.total || 0;
-			const result = {
-				method: "offset",
-				docs: facetResult.data || [],
-				page,
-				limit,
-				total,
-				pages: Math.max(1, Math.ceil(total / limit)),
-				hasNext: page * limit < total,
-				hasPrev: page > 1
-			};
-			await this._emitHook("after:lookupPopulate", {
-				context,
-				result
-			});
-			return result;
-		} catch (error) {
-			await this._emitErrorHook("error:lookupPopulate", {
-				context,
-				error
-			});
-			throw this._handleError(error);
-		}
-	}
-	/**
-	* Create an aggregation builder for this model
-	* Useful for building complex custom aggregations
-	*
-	* @example
-	* ```typescript
-	* const pipeline = repo.buildAggregation()
-	*   .match({ status: 'active' })
-	*   .lookup('departments', 'deptSlug', 'slug', 'department', true)
-	*   .group({ _id: '$department', count: { $sum: 1 } })
-	*   .sort({ count: -1 })
-	*   .build();
-	*
-	* const results = await repo.Model.aggregate(pipeline);
-	* ```
-	*/
-	buildAggregation() {
-		return new AggregationBuilder();
-	}
-	/**
-	* Create a lookup builder
-	* Useful for building $lookup stages independently
-	*
-	* @example
-	* ```typescript
-	* const lookupStages = repo.buildLookup('departments')
-	*   .localField('deptSlug')
-	*   .foreignField('slug')
-	*   .as('department')
-	*   .single()
-	*   .build();
-	*
-	* const pipeline = [
-	*   { $match: { status: 'active' } },
-	*   ...lookupStages
-	* ];
-	* ```
-	*/
-	buildLookup(from) {
-		return new LookupBuilder(from);
-	}
-	/**
-	* Execute callback within a MongoDB transaction with automatic retry on
-	* transient failures.
-	*
-	* **BREAKING (3.10):** the callback now receives a **tx-bound repository**,
-	* not a raw `ClientSession`. This matches repo-core's `StandardRepo.withTransaction`
-	* contract that every kit (sqlitekit, pgkit, prismakit) already implements
-	* — so cross-kit plugins and apps are portable. Session threading happens
-	* transparently: every CRUD call on `txRepo` auto-injects the session into
-	* its options bag, including plugin-added methods (`upsert`, `increment`,
-	* `updateMany`, `restore`, ...). Nested `txRepo.withTransaction(...)` throws.
-	*
-	* For raw-session cross-repo workflows — multiple repositories coordinating
-	* writes — use the standalone `withTransaction(connection, fn)` export
-	* from `@classytic/mongokit`. That helper remains session-based by design.
-	*
-	* @param callback - Receives a tx-bound `Repository<TDoc>` — call its
-	*                   methods directly, no need to pass `{ session }` manually
-	* @param options.allowFallback - Run without transaction on standalone MongoDB (default: false)
-	* @param options.onFallback - Called when falling back to non-transactional execution
-	* @param options.transactionOptions - MongoDB driver transaction options (readConcern, writeConcern, etc.)
-	*
-	* @example
-	* ```typescript
-	* const order = await repo.withTransaction(async (txRepo) => {
-	*   const created = await txRepo.create({ total: 100 });
-	*   await txRepo.update(created._id, { confirmed: true });
-	*   return created;
-	* });
-	*
-	* // With fallback for standalone/dev environments
-	* await repo.withTransaction(
-	*   async (txRepo) => {
-	*     await txRepo.create(doc);
-	*   },
-	*   {
-	*     allowFallback: true,
-	*     onFallback: (err) => logger.warn('Running without transaction', err),
-	*   },
-	* );
-	*
-	* // Cross-repo with explicit session:
-	* import { withTransaction } from '@classytic/mongokit';
-	* await withTransaction(mongoose.connection, async (session) => {
-	*   const order = await orderRepo.create(data, { session });
-	*   await inventoryRepo.decrement(..., { session });
-	* });
-	* ```
-	*/
-	async withTransaction(callback, options = {}) {
-		return withTransaction(this.Model.db, async (session) => {
-			return callback(createTxBoundRepo(this, session));
-		}, options);
-	}
-	/**
-	* Execute custom query with event emission
-	*/
-	async _executeQuery(buildQuery) {
-		const operation = buildQuery.name || "custom";
-		const context = await this._buildContext(operation, {});
-		return this._runOp(operation, context, () => buildQuery(this.Model));
-	}
-	/**
-	* Build operation context and run before-hooks (sorted by priority).
-	*
-	* Narrows `RepositoryBase._buildContext`'s return type to mongokit's
-	* richer `RepositoryContext` (which carries `softDeleted`, `_cacheHit`,
-	* populate / readPreference / session, etc.). Runtime is inherited from
-	* the base class — this override is purely a type-narrowing shim.
-	*
-	* Hook execution order is deterministic:
-	* 1. POLICY (100) — tenant isolation, soft-delete filtering, validation
-	* 2. CACHE  (200) — cache lookup (after policy filters are injected)
-	* 3. OBSERVABILITY (300) — audit logging, metrics
-	* 4. DEFAULT (500) — user-registered hooks
-	*/
-	async _buildContext(operation, options) {
-		const normalized = this._normalizeFilterSlots(options);
-		return await super._buildContext(operation, normalized);
-	}
-	/**
-	* Walk the well-known filter-carrying keys (`query`, `filters`,
-	* `having`) and route any Filter IR through `compileFilterToMongo`.
-	* Plain Mongo queries pass through untouched — `isFilter` is the
-	* discriminator. Returns a shallow clone; never mutates input.
-	*/
-	_normalizeFilterSlots(options) {
-		let cloned = null;
-		for (const key of [
-			"query",
-			"filters",
-			"having"
-		]) {
-			const value = options[key];
-			if (value === void 0 || value === null) continue;
-			if (!isFilter(value)) continue;
-			cloned ??= { ...options };
-			cloned[key] = compileFilterToMongo(value);
-		}
-		return cloned ?? options;
-	}
-	/**
-	* Resolve the effective sort for getAll. Handles $near conflict detection
-	* (warns + drops explicit sort when $near is in filters).
-	*/
-	_resolveSort(context, params, isNearQuery) {
-		const explicitSort = context.sort ?? params.sort;
-		if (isNearQuery) {
-			if (explicitSort !== void 0) warn(`[mongokit] Repository "${this.model}" dropping explicit sort (${JSON.stringify(explicitSort)}) because the filter contains $near / $nearSphere. MongoDB forbids explicit sort with $near. Use [withinRadius] instead of [near] if you need a custom sort.`);
-			return;
-		}
-		return explicitSort ?? "-createdAt";
-	}
-	/**
-	* Detect whether to use keyset (cursor) or offset (page) pagination.
-	*/
-	_detectPaginationMode(mode, page, after, sort, context, params) {
-		if (mode) return mode === "keyset";
-		return !page && !!(after || sort !== "-createdAt" && (context.sort ?? params.sort));
-	}
-	/**
-	* Build the MongoDB query filter with search merged in. Handles text
-	* search ($text), regex search ($or of $regex), and the search-resolver
-	* plugin contract (search already cleared by a before:getAll hook).
-	*/
-	_buildSearchQuery(filters, search) {
-		const query = { ...filters };
-		if (!search) return query;
-		if (this._hasTextIndex === null) this._hasTextIndex = this.Model.schema.indexes().some((idx) => idx[0] && Object.values(idx[0]).includes("text"));
-		let effectiveMode = this.searchMode === "regex" ? "regex" : "text";
-		if (this.searchMode === "auto") effectiveMode = this._hasTextIndex ? "text" : "regex";
-		if (effectiveMode === "regex") {
-			if (!this.searchFields || this.searchFields.length === 0) throw createError(400, `Repository "${this.model}" configured with searchMode: '${this.searchMode}' but no searchFields provided.`);
-			const escaped = String(search).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-			const orConds = this.searchFields.map((field) => ({ [field]: {
-				$regex: escaped,
-				$options: "i"
-			} }));
-			if (Array.isArray(query.$or)) {
-				const existingOr = query.$or;
-				delete query.$or;
-				query.$and = [
-					...Array.isArray(query.$and) ? query.$and : [],
-					{ $or: existingOr },
-					{ $or: orConds }
-				];
-			} else query.$or = orConds;
-		} else if (this._hasTextIndex) query.$text = { $search: search };
-		else {
-			const modelName = String(this.model);
-			throw createError(400, `No text index found for ${modelName}. Cannot perform text search. Configure ${modelName}'s Repository with { searchMode: 'regex', searchFields: [...] } to enable index-free search, or create a text index on the collection for searchMode: 'text'. See https://github.com/classytic/mongokit/blob/main/docs/README.md#queryparser-url--filter`, {
-				code: "SEARCH_NOT_CONFIGURED",
-				meta: {
-					model: modelName,
-					configuredMode: this.searchMode,
-					availableModes: [
-						"text",
-						"regex",
-						"auto"
-					],
-					docs: "https://github.com/classytic/mongokit/blob/main/docs/README.md#queryparser-url--filter"
-				}
-			});
-		}
-		return query;
-	}
-	/**
-	* Parse sort string or object
-	*/
-	_parseSort(sort) {
-		if (!sort) return { createdAt: -1 };
-		if (typeof sort === "object") {
-			if (Object.keys(sort).length === 0) return { createdAt: -1 };
-			return sort;
-		}
-		const sortObj = {};
-		const fields = sort.split(",").map((s) => s.trim());
-		for (const field of fields) if (field.startsWith("-")) sortObj[field.substring(1)] = -1;
-		else sortObj[field] = 1;
-		return sortObj;
-	}
-	/**
-	* Parse populate specification
-	*/
-	_parsePopulate(populate) {
-		if (!populate) return [];
-		if (typeof populate === "string") return populate.split(",").map((p) => p.trim());
-		if (Array.isArray(populate)) return populate.map((p) => typeof p === "string" ? p.trim() : p);
-		return [populate];
-	}
-	/**
-	* Classify a driver error as an authoritative duplicate-key conflict.
-	*
-	* Used by arc's outbox / idempotency adapters to distinguish
-	* "write already landed (idempotent no-op)" from "transient DB error
-	* (must retry)". Every backend signals duplicate keys differently —
-	* MongoDB `code: 11000`, Prisma `P2002`, Postgres `23505` — so this
-	* predicate lives on the kit that knows its driver. Cross-driver
-	* adapters then depend only on the boolean outcome, not the shape of
-	* the underlying error.
-	*
-	* Deliberately narrow: matches ONLY `code === 11000` and
-	* `codeName === 'DuplicateKey'`. Does NOT match
-	* `err.name === 'MongoServerError'`, which is also true for
-	* WriteConflict, NotWritablePrimary, ExceededTimeLimit, and every
-	* other server-side error — treating those as duplicate keys would
-	* silently swallow transactional retries.
-	*
-	* @example
-	* try {
-	*   await outboxRepo.create(event);
-	* } catch (err) {
-	*   if (outboxRepo.isDuplicateKeyError(err)) {
-	*     // Idempotent no-op — event was already written by a prior attempt.
-	*     return;
-	*   }
-	*   throw err; // transient DB error — upstream retries
-	* }
-	*/
-	isDuplicateKeyError(err) {
-		return isDuplicateKeyError(err);
-	}
-	/**
-	* Handle errors with proper HTTP status codes
-	*/
-	_handleError(error) {
-		if (error instanceof mongoose.Error.ValidationError) return createError(400, `Validation Error: ${Object.values(error.errors).map((err) => err.message).join(", ")}`);
-		if (error instanceof mongoose.Error.CastError) return createError(400, `Invalid ${error.path}: ${error.value}`);
-		const duplicateErr = parseDuplicateKeyError(error);
-		if (duplicateErr) return duplicateErr;
-		if (error.status && error.message) return error;
-		return createError(500, error.message || "Internal Server Error");
-	}
-};
-//#endregion
-//#region src/plugins/cache.plugin.ts
-/**
-* Cache Plugin
-*
-* Optional caching layer for MongoKit with automatic invalidation.
-* Bring-your-own cache adapter (Redis, Memcached, in-memory, etc.)
-*
-* Features:
-* - Cache-aside (read-through) pattern with configurable TTLs
-* - Automatic invalidation on create/update/delete
-* - Collection version tags for efficient list cache invalidation
-* - Manual invalidation methods for microservice scenarios
-* - Skip cache per-operation with `skipCache: true`
-*
-* @example
-* ```typescript
-* import { Repository, cachePlugin } from '@classytic/mongokit';
-* import Redis from 'ioredis';
-*
-* const redis = new Redis();
-*
-* const userRepo = new Repository(UserModel, [
-*   cachePlugin({
-*     adapter: {
-*       async get(key) { return JSON.parse(await redis.get(key) || 'null'); },
-*       async set(key, value, ttl) { await redis.setex(key, ttl, JSON.stringify(value)); },
-*       async delete(key) { await redis.del(key); },
-*       async clear(pattern) {
-*         const keys = await redis.keys(pattern || '*');
-*         if (keys.length) await redis.del(...keys);
-*       }
-*     },
-*     ttl: 60, // 1 minute default
-*   })
-* ]);
-*
-* // Reads check cache first
-* const user = await userRepo.getById(id); // cached
-*
-* // Skip cache for fresh data
-* const fresh = await userRepo.getById(id, { skipCache: true });
-*
-* // Mutations auto-invalidate
-* await userRepo.update(id, { name: 'New Name' }); // invalidates cache
-*
-* // Manual invalidation for microservice sync
-* await userRepo.invalidateCache(id); // invalidate single doc
-* await userRepo.invalidateAllCache(); // invalidate all for this model
-* ```
-*/
-/**
-* Resolve the user's jitter config into a deterministic `ttl -> ttl` function.
-*
-* - `undefined` / `0`: identity (no jitter).
-* - number in (0, 1]: symmetric fractional jitter. `0.1` → uniform in [0.9, 1.1].
-* - function: used as-is; caller owns the math. Clamped to >= 1s below.
-*
-* The final TTL is always clamped to a whole second >= 1 so adapters that
-* treat 0 as "no expiry" (Redis SETEX semantics) don't accidentally persist
-* entries forever.
-*/
-function resolveJitter(jitter) {
-	if (!jitter) return (ttl) => ttl;
-	if (typeof jitter === "function") return (ttl) => Math.max(1, Math.round(jitter(ttl)));
-	const fraction = Math.min(1, Math.max(0, jitter));
-	if (fraction === 0) return (ttl) => ttl;
-	return (ttl) => {
-		const delta = ttl * fraction;
-		const jittered = ttl - delta + Math.random() * 2 * delta;
-		return Math.max(1, Math.round(jittered));
-	};
-}
-/**
-* Cache plugin factory
-*
-* @param options - Cache configuration
-* @returns Plugin instance
-*/
-function cachePlugin(options) {
-	const config = {
-		adapter: options.adapter,
-		ttl: options.ttl ?? 60,
-		byIdTtl: options.byIdTtl ?? options.ttl ?? 60,
-		queryTtl: options.queryTtl ?? options.ttl ?? 60,
-		prefix: options.prefix ?? "mk",
-		debug: options.debug ?? false,
-		skipIfLargeLimit: options.skipIf?.largeLimit ?? 100,
-		applyJitter: resolveJitter(options.jitter)
-	};
-	const stats = {
-		hits: 0,
-		misses: 0,
-		sets: 0,
-		invalidations: 0,
-		errors: 0
-	};
-	const log = (msg, data) => {
-		if (config.debug) debug(`[mongokit:cache] ${msg}`, data ?? "");
-	};
-	return {
-		name: "cache",
-		apply(repo) {
-			const model = repo.model;
-			const byIdKeyRegistry = /* @__PURE__ */ new Map();
-			function trackByIdKey(docId, cacheKey) {
-				let keys = byIdKeyRegistry.get(docId);
-				if (!keys) {
-					keys = /* @__PURE__ */ new Set();
-					byIdKeyRegistry.set(docId, keys);
-				}
-				keys.add(cacheKey);
-			}
-			async function getVersion() {
-				try {
-					return await config.adapter.get(versionKey(config.prefix, model)) ?? 0;
-				} catch (e) {
-					log(`Cache error in getVersion for ${model}:`, e);
-					return 0;
-				}
-			}
-			/**
-			* Bump collection version in the adapter (invalidates all list caches).
-			* Uses Date.now() so version always moves forward — safe after eviction or deploy.
-			*/
-			async function bumpVersion() {
-				const newVersion = Date.now();
-				try {
-					await config.adapter.set(versionKey(config.prefix, model), newVersion, config.applyJitter(config.ttl * 10));
-					stats.invalidations++;
-					log(`Bumped version for ${model} to:`, newVersion);
-				} catch (e) {
-					log(`Failed to bump version for ${model}:`, e);
-				}
-			}
-			/**
-			* Invalidate a specific document by ID (all shape variants).
-			* Deletes every tracked shape-variant key individually via delete(),
-			* so adapters without pattern-based clear() still get full invalidation.
-			*/
-			async function invalidateById(id) {
-				try {
-					const baseKey = byIdKey(config.prefix, model, id);
-					await config.adapter.delete(baseKey);
-					const trackedKeys = byIdKeyRegistry.get(id);
-					if (trackedKeys) {
-						for (const key of trackedKeys) if (key !== baseKey) await config.adapter.delete(key);
-						byIdKeyRegistry.delete(id);
-					}
-					stats.invalidations++;
-					log(`Invalidated byId cache for:`, id);
-				} catch (e) {
-					log(`Failed to invalidate byId cache:`, e);
-				}
-			}
-			/**
-			* before:getById - Check cache for document
-			* Runs at CACHE priority (200) — after policy hooks inject filters
-			*/
-			repo.on("before:getById", async (context) => {
-				if (context.skipCache) {
-					log(`Skipping cache for getById: ${context.id}`);
-					return;
-				}
-				const id = String(context.id);
-				const key = byIdKey(config.prefix, model, id, {
-					select: context.select,
-					populate: context.populate,
-					lean: context.lean
-				});
-				try {
-					const cached = await config.adapter.get(key);
-					if (cached !== null) {
-						stats.hits++;
-						log(`Cache HIT for getById:`, key);
-						context._cacheHit = true;
-						context._cachedResult = cached;
-					} else {
-						stats.misses++;
-						log(`Cache MISS for getById:`, key);
-					}
-				} catch (e) {
-					log(`Cache error for getById:`, e);
-					stats.errors++;
-				}
-			}, { priority: HOOK_PRIORITY$1.CACHE });
-			/**
-			* before:getByQuery - Check cache for single-doc query
-			* Runs at CACHE priority (200) — after policy hooks inject filters
-			*/
-			repo.on("before:getByQuery", async (context) => {
-				if (context.skipCache) {
-					log(`Skipping cache for getByQuery`);
-					return;
-				}
-				const collectionVersion = await getVersion();
-				const query = context.query || {};
-				const key = byQueryKey(config.prefix, model, collectionVersion, query, {
-					select: context.select,
-					populate: context.populate
-				});
-				try {
-					const cached = await config.adapter.get(key);
-					if (cached !== null) {
-						stats.hits++;
-						log(`Cache HIT for getByQuery:`, key);
-						context._cacheHit = true;
-						context._cachedResult = cached;
-					} else {
-						stats.misses++;
-						log(`Cache MISS for getByQuery:`, key);
-					}
-				} catch (e) {
-					log(`Cache error for getByQuery:`, e);
-					stats.errors++;
-				}
-			}, { priority: HOOK_PRIORITY$1.CACHE });
-			/**
-			* before:getOne - Same cache logic as getByQuery (single-doc)
-			*/
-			repo.on("before:getOne", async (context) => {
-				if (context.skipCache) return;
-				try {
-					const collectionVersion = await getVersion();
-					const query = context.query || {};
-					const key = byQueryKey(config.prefix, model, collectionVersion, query, {
-						select: context.select,
-						populate: context.populate
-					});
-					const cached = await config.adapter.get(key);
-					if (cached !== null && cached !== void 0) {
-						log(`Cache HIT for getOne: ${key}`);
-						stats.hits++;
-						context._cacheHit = true;
-						context._cachedResult = cached;
-					} else {
-						log(`Cache MISS for getOne: ${key}`);
-						stats.misses++;
-						context._cacheKey = key;
-					}
-				} catch (e) {
-					log(`Cache error for getOne:`, e);
-					stats.errors++;
-				}
-			}, { priority: HOOK_PRIORITY$1.CACHE });
-			/**
-			* before:getAll - Check cache for list query
-			* Runs at CACHE priority (200) — after policy hooks inject filters
-			*/
-			repo.on("before:getAll", async (context) => {
-				if (context.skipCache) {
-					log(`Skipping cache for getAll`);
-					return;
-				}
-				const limit = context.limit;
-				if (limit && limit > config.skipIfLargeLimit) {
-					log(`Skipping cache for large query (limit: ${limit})`);
-					return;
-				}
-				const collectionVersion = await getVersion();
-				const params = {
-					filters: context.filters,
-					sort: context.sort,
-					page: context.page,
-					limit,
-					after: context.after,
-					select: context.select,
-					populate: context.populate,
-					search: context.search,
-					mode: context.mode,
-					lean: context.lean,
-					readPreference: context.readPreference,
-					hint: context.hint,
-					maxTimeMS: context.maxTimeMS,
-					countStrategy: context.countStrategy
-				};
-				const key = listQueryKey(config.prefix, model, collectionVersion, params);
-				try {
-					const cached = await config.adapter.get(key);
-					if (cached !== null) {
-						stats.hits++;
-						log(`Cache HIT for getAll:`, key);
-						context._cacheHit = true;
-						context._cachedResult = cached;
-					} else {
-						stats.misses++;
-						log(`Cache MISS for getAll:`, key);
-					}
-				} catch (e) {
-					log(`Cache error for getAll:`, e);
-					stats.errors++;
-				}
-			}, { priority: HOOK_PRIORITY$1.CACHE });
-			/**
-			* after:getById - Cache the result
-			*/
-			repo.on("after:getById", async (payload) => {
-				const { context, result } = payload;
-				if (context._cacheHit) return;
-				if (context.skipCache) return;
-				if (result === null) return;
-				const id = String(context.id);
-				const key = byIdKey(config.prefix, model, id, {
-					select: context.select,
-					populate: context.populate,
-					lean: context.lean
-				});
-				const ttl = config.applyJitter(context.cacheTtl ?? config.byIdTtl);
-				try {
-					await config.adapter.set(key, result, ttl);
-					trackByIdKey(id, key);
-					stats.sets++;
-					log(`Cached getById result:`, key);
-				} catch (e) {
-					log(`Failed to cache getById:`, e);
-				}
-			});
-			/**
-			* after:getByQuery - Cache the result
-			*/
-			repo.on("after:getByQuery", async (payload) => {
-				const { context, result } = payload;
-				if (context._cacheHit) return;
-				if (context.skipCache) return;
-				if (result === null) return;
-				const collectionVersion = await getVersion();
-				const query = context.query || {};
-				const key = byQueryKey(config.prefix, model, collectionVersion, query, {
-					select: context.select,
-					populate: context.populate
-				});
-				const ttl = config.applyJitter(context.cacheTtl ?? config.queryTtl);
-				try {
-					await config.adapter.set(key, result, ttl);
-					stats.sets++;
-					log(`Cached getByQuery result:`, key);
-				} catch (e) {
-					log(`Failed to cache getByQuery:`, e);
-				}
-			});
-			/**
-			* after:getOne - Cache the result (same as getByQuery)
-			*/
-			repo.on("after:getOne", async (payload) => {
-				const { context, result } = payload;
-				if (context._cacheHit || context.skipCache || result === null) return;
-				const collectionVersion = await getVersion();
-				const query = context.query || {};
-				const key = byQueryKey(config.prefix, model, collectionVersion, query, {
-					select: context.select,
-					populate: context.populate
-				});
-				try {
-					await config.adapter.set(key, result, config.applyJitter(context.cacheTtl ?? config.queryTtl));
-					stats.sets++;
-				} catch (e) {
-					log(`Failed to cache getOne:`, e);
-				}
-			});
-			/**
-			* after:getAll - Cache the result
-			*/
-			repo.on("after:getAll", async (payload) => {
-				const { context, result } = payload;
-				if (context._cacheHit) return;
-				if (context.skipCache) return;
-				const limit = context.limit;
-				if (limit && limit > config.skipIfLargeLimit) return;
-				const collectionVersion = await getVersion();
-				const params = {
-					filters: context.filters,
-					sort: context.sort,
-					page: context.page,
-					limit,
-					after: context.after,
-					select: context.select,
-					populate: context.populate,
-					search: context.search,
-					mode: context.mode,
-					lean: context.lean,
-					readPreference: context.readPreference,
-					hint: context.hint,
-					maxTimeMS: context.maxTimeMS,
-					countStrategy: context.countStrategy
-				};
-				const key = listQueryKey(config.prefix, model, collectionVersion, params);
-				const ttl = config.applyJitter(context.cacheTtl ?? config.queryTtl);
-				try {
-					await config.adapter.set(key, result, ttl);
-					stats.sets++;
-					log(`Cached getAll result:`, key);
-				} catch (e) {
-					log(`Failed to cache getAll:`, e);
-				}
-			});
-			/**
-			* after:create - Bump version to invalidate list caches
-			*/
-			repo.on("after:create", async () => {
-				await bumpVersion();
-			});
-			/**
-			* after:createMany - Bump version to invalidate list caches
-			*/
-			repo.on("after:createMany", async () => {
-				await bumpVersion();
-			});
-			/**
-			* after:update - Invalidate by ID and bump version
-			*/
-			repo.on("after:update", async (payload) => {
-				const { context } = payload;
-				const id = String(context.id);
-				await Promise.all([invalidateById(id), bumpVersion()]);
-			});
-			/**
-			* after:updateMany - Bump version (can't track individual IDs efficiently)
-			*/
-			repo.on("after:updateMany", async () => {
-				await bumpVersion();
-			});
-			/**
-			* after:findOneAndUpdate — atomic CAS may insert (upsert) or mutate.
-			* Result carries the matched/inserted doc; invalidate that ID and bump
-			* version. Null result (no match, no upsert) is a no-op.
-			*/
-			repo.on("after:findOneAndUpdate", async (payload) => {
-				const { result } = payload;
-				if (!result) return;
-				const idKey = repo.idField || "_id";
-				const id = result?.[idKey];
-				if (id == null) {
-					await bumpVersion();
-					return;
-				}
-				await Promise.all([invalidateById(String(id)), bumpVersion()]);
-			});
-			/**
-			* after:delete - Invalidate by ID and bump version
-			*/
-			repo.on("after:delete", async (payload) => {
-				const { context } = payload;
-				const id = String(context.id);
-				await Promise.all([invalidateById(id), bumpVersion()]);
-			});
-			/**
-			* after:deleteMany - Bump version
-			*/
-			repo.on("after:deleteMany", async () => {
-				await bumpVersion();
-			});
-			/**
-			* after:bulkWrite - Bump version (bulk ops may insert/update/delete)
-			*/
-			repo.on("after:bulkWrite", async () => {
-				await bumpVersion();
-			});
-			/**
-			* Invalidate cache for a specific document
-			* Use when document was updated outside this service
-			*
-			* @example
-			* await userRepo.invalidateCache('507f1f77bcf86cd799439011');
-			*/
-			repo.invalidateCache = async (id) => {
-				await invalidateById(id);
-				log(`Manual invalidation for ID:`, id);
-			};
-			/**
-			* Invalidate all list caches for this model
-			* Use when bulk changes happened outside this service
-			*
-			* @example
-			* await userRepo.invalidateListCache();
-			*/
-			repo.invalidateListCache = async () => {
-				await bumpVersion();
-				log(`Manual list cache invalidation for ${model}`);
-			};
-			/**
-			* Invalidate ALL cache entries for this model
-			* Nuclear option - use sparingly
-			*
-			* @example
-			* await userRepo.invalidateAllCache();
-			*/
-			repo.invalidateAllCache = async () => {
-				if (config.adapter.clear) try {
-					await config.adapter.clear(modelPattern(config.prefix, model));
-					stats.invalidations++;
-					log(`Full cache invalidation for ${model}`);
-				} catch (e) {
-					log(`Failed full cache invalidation for ${model}:`, e);
-				}
-				else {
-					await bumpVersion();
-					log(`Partial cache invalidation for ${model} (adapter.clear not available)`);
-				}
-			};
-			/**
-			* Get cache statistics for monitoring
-			*
-			* @example
-			* const stats = userRepo.getCacheStats();
-			* console.log(`Hit rate: ${stats.hits / (stats.hits + stats.misses) * 100}%`);
-			*/
-			repo.getCacheStats = () => ({ ...stats });
-			/**
-			* Reset cache statistics
-			*/
-			repo.resetCacheStats = () => {
-				stats.hits = 0;
-				stats.misses = 0;
-				stats.sets = 0;
-				stats.invalidations = 0;
-				stats.errors = 0;
-			};
-		}
-	};
-}
-//#endregion
-//#region src/plugins/cascade.plugin.ts
-/**
-* Cascade Delete Plugin
-*
-* Automatically deletes related documents when a parent document is deleted.
-*
-* Two routing modes per relation:
-*
-*   1. **Repo-routed (preferred)** — pass `repo: targetRepo` on the relation.
-*      Cascade calls `targetRepo.delete(id, { mode })` / `targetRepo.deleteMany(
-*      query, { mode })`, so the target's `before:delete` / `before:deleteMany`
-*      hooks fire. Multi-tenant scoping, audit logging, cache invalidation,
-*      and the target's own `softDeletePlugin` (with its configured
-*      `deletedField`) all run correctly.
-*
-*   2. **Model-routed (legacy)** — pass `model: 'TargetModelName'`. Cascade
-*      writes directly via `mongoose.models[name].updateMany / deleteMany`,
-*      **bypassing** the target's hooks. Safe only for trivial targets with
-*      no policy plugins. Retained for backwards compatibility — prefer the
-*      repo-routed form for new code.
-*
-* The parent's delete mode propagates: a hard-deleted parent cascades hard,
-* a soft-deleted parent cascades soft — unless `relation.softDelete` overrides
-* the decision per-relation.
-*
-* @example Repo-routed (new)
-* ```ts
-* const productRepo = new Repository(Product, [
-*   methodRegistryPlugin(),
-*   cascadePlugin({
-*     relations: [
-*       { repo: stockEntryRepo,    foreignKey: 'product' },
-*       { repo: stockMovementRepo, foreignKey: 'product' },
-*     ],
-*   }),
-* ]);
-* ```
-*
-* @example Model-routed (legacy)
-* ```ts
-* cascadePlugin({
-*   relations: [
-*     { model: 'StockEntry', foreignKey: 'product' },
-*   ],
-* });
-* ```
-*/
-/**
-* Collect top-level parent-context fields that a target plugin (multi-tenant,
-* audit) will likely need. We can't know the target's contextKey, so we
-* forward a well-known allow-list: `organizationId`, `tenantId`, and `user`.
-* These are the conventions enforced by the built-in plugins.
-*/
-function collectScopeForward(context) {
-	const out = {};
-	if (context.organizationId !== void 0) out.organizationId = context.organizationId;
-	if (context.tenantId !== void 0) out.tenantId = context.tenantId;
-	if (context.user !== void 0) out.user = context.user;
-	return out;
-}
-/**
-* Cascade delete plugin.
-*/
-function cascadePlugin(options) {
-	const { relations, parallel = true, logger } = options;
-	if (!relations || relations.length === 0) throw new Error("cascadePlugin requires at least one relation");
-	for (const rel of relations) {
-		if (!rel.repo && !rel.model) throw new Error("cascadePlugin: each relation needs either `repo` (preferred) or `model` (legacy)");
-		if (!rel.foreignKey) throw new Error("cascadePlugin: each relation needs `foreignKey`");
-	}
-	return {
-		name: "cascade",
-		apply(repo) {
-			repo.on("after:delete", async (payload) => {
-				const { context } = payload;
-				const deletedId = context.id;
-				if (!deletedId) {
-					logger?.warn?.("Cascade delete skipped: no document ID in context", { model: context.model });
-					return;
-				}
-				const isSoftParent = context.softDeleted === true;
-				const scopeForward = collectScopeForward(context);
-				const cascadeOne = async (relation) => {
-					const shouldSoftDelete = relation.softDelete ?? isSoftParent;
-					const cascadeCtx = {
-						targetModelName: relation.repo ? relation.repo.Model?.modelName ?? "<unknown>" : relation.model ?? "<unknown>",
-						session: context.session,
-						shouldSoftDelete,
-						user: context.user,
-						scopeForward
-					};
-					try {
-						if (relation.repo) await cascadeViaRepoBulk(relation, deletedId, cascadeCtx);
-						else await cascadeViaLegacyModel(relation, deletedId, cascadeCtx, logger);
-					} catch (error) {
-						logger?.error?.(`Cascade delete failed for '${cascadeCtx.targetModelName}'`, {
-							parentModel: context.model,
-							parentId: String(deletedId),
-							relatedModel: cascadeCtx.targetModelName,
-							foreignKey: relation.foreignKey,
-							error: error.message
-						});
-						throw error;
-					}
-				};
-				await runCascades(relations, cascadeOne, parallel);
-			});
-			repo.on("before:deleteMany", async (context) => {
-				const query = context.query;
-				if (!query || Object.keys(query).length === 0) return;
-				const idField = repo.idField || "_id";
-				context._cascadeIds = (await repo.Model.find(query, { [idField]: 1 }).lean().session(context.session ?? null)).map((doc) => doc[idField]);
-			});
-			repo.on("after:deleteMany", async (payload) => {
-				const { context } = payload;
-				const ids = context._cascadeIds;
-				if (!ids || ids.length === 0) return;
-				const isSoftParent = context.softDeleted === true;
-				const scopeForward = collectScopeForward(context);
-				const cascadeBulk = async (relation) => {
-					const shouldSoftDelete = relation.softDelete ?? isSoftParent;
-					const cascadeCtx = {
-						targetModelName: relation.repo ? relation.repo.Model?.modelName ?? "<unknown>" : relation.model ?? "<unknown>",
-						session: context.session,
-						shouldSoftDelete,
-						user: context.user,
-						scopeForward
-					};
-					try {
-						if (relation.repo) await cascadeViaRepoBulkMany(relation, ids, cascadeCtx);
-						else await cascadeViaLegacyModelMany(relation, ids, cascadeCtx, logger);
-					} catch (error) {
-						logger?.error?.(`Cascade deleteMany failed for '${cascadeCtx.targetModelName}'`, {
-							parentModel: context.model,
-							relatedModel: cascadeCtx.targetModelName,
-							foreignKey: relation.foreignKey,
-							error: error.message
-						});
-						throw error;
-					}
-				};
-				await runCascades(relations, cascadeBulk, parallel);
-			});
-		}
-	};
-}
-/**
-* Repo-routed cascade for a single parent delete.
-* Calls `repo.deleteMany({ [fk]: parentId }, { mode })` — respects all target
-* hooks (multi-tenant, audit, target's own soft-delete plugin).
-*/
-async function cascadeViaRepoBulk(relation, parentId, ctx) {
-	const targetRepo = relation.repo;
-	if (typeof targetRepo.deleteMany !== "function") throw new Error(`cascadePlugin: target repo for '${ctx.targetModelName}' is missing deleteMany(). Ensure the target is a mongokit Repository or implements the StandardRepo deleteMany contract.`);
-	await targetRepo.deleteMany({ [relation.foreignKey]: parentId }, {
-		...ctx.scopeForward,
-		mode: ctx.shouldSoftDelete ? "soft" : "hard",
-		session: ctx.session
-	});
-}
-/**
-* Repo-routed cascade for a bulk parent deleteMany — `$in` over snapshot ids.
-*/
-async function cascadeViaRepoBulkMany(relation, parentIds, ctx) {
-	const targetRepo = relation.repo;
-	if (typeof targetRepo.deleteMany !== "function") throw new Error(`cascadePlugin: target repo for '${ctx.targetModelName}' is missing deleteMany(). Ensure the target is a mongokit Repository or implements the StandardRepo deleteMany contract.`);
-	await targetRepo.deleteMany({ [relation.foreignKey]: { $in: parentIds } }, {
-		...ctx.scopeForward,
-		mode: ctx.shouldSoftDelete ? "soft" : "hard",
-		session: ctx.session
-	});
-}
-/**
-* Legacy cascade via `mongoose.models[name]`. Bypasses target hooks.
-* Retained for backwards compatibility with existing cascadePlugin consumers.
-*/
-async function cascadeViaLegacyModel(relation, parentId, ctx, logger) {
-	const RelatedModel = mongoose.models[relation.model];
-	if (!RelatedModel) {
-		logger?.warn?.(`Cascade delete skipped: model '${relation.model}' not found`);
-		return;
-	}
-	const query = { [relation.foreignKey]: parentId };
-	if (ctx.shouldSoftDelete) await RelatedModel.updateMany(query, {
-		deletedAt: /* @__PURE__ */ new Date(),
-		...ctx.user ? { deletedBy: ctx.user._id || ctx.user.id } : {}
-	}, { session: ctx.session });
-	else await RelatedModel.deleteMany(query, { session: ctx.session });
-}
-async function cascadeViaLegacyModelMany(relation, parentIds, ctx, logger) {
-	const RelatedModel = mongoose.models[relation.model];
-	if (!RelatedModel) {
-		logger?.warn?.(`Cascade deleteMany skipped: model '${relation.model}' not found`);
-		return;
-	}
-	const query = { [relation.foreignKey]: { $in: parentIds } };
-	if (ctx.shouldSoftDelete) await RelatedModel.updateMany(query, {
-		deletedAt: /* @__PURE__ */ new Date(),
-		...ctx.user ? { deletedBy: ctx.user._id || ctx.user.id } : {}
-	}, { session: ctx.session });
-	else await RelatedModel.deleteMany(query, { session: ctx.session });
-}
-/**
-* Execute a list of cascade operations, honoring the `parallel` flag.
-* Uses `allSettled` so one failure doesn't abort siblings; throws the first
-* rejection (with a composite message if several failed) after all complete.
-*/
-async function runCascades(relations, fn, parallel) {
-	if (parallel) {
-		const failures = (await Promise.allSettled(relations.map(fn))).filter((r) => r.status === "rejected");
-		if (failures.length) {
-			const err = failures[0].reason;
-			if (failures.length > 1) err.message = `${failures.length} cascade deletes failed. First: ${err.message}`;
-			throw err;
-		}
-	} else for (const relation of relations) await fn(relation);
-}
-//#endregion
-//#region src/plugins/custom-id.plugin.ts
-/**
-* Custom ID Plugin
-*
-* Generates custom document IDs using pluggable generators.
-* Supports atomic counters for sequential IDs (e.g., INV-2026-0001),
-* date-partitioned sequences, and fully custom generators.
-*
-* Uses MongoDB's atomic `findOneAndUpdate` with `$inc` on a dedicated
-* counters collection — guaranteeing no duplicate IDs under concurrency.
-*
-* @example Basic sequential counter
-* ```typescript
-* const invoiceRepo = new Repository(InvoiceModel, [
-*   customIdPlugin({
-*     field: 'invoiceNumber',
-*     generator: sequentialId({
-*       prefix: 'INV',
-*       model: InvoiceModel,
-*     }),
-*   }),
-* ]);
-*
-* const inv = await invoiceRepo.create({ amount: 100 });
-* // inv.invoiceNumber → "INV-0001"
-* ```
-*
-* @example Date-partitioned counter (resets monthly)
-* ```typescript
-* const billRepo = new Repository(BillModel, [
-*   customIdPlugin({
-*     field: 'billNumber',
-*     generator: dateSequentialId({
-*       prefix: 'BILL',
-*       model: BillModel,
-*       partition: 'monthly',
-*       separator: '-',
-*       padding: 4,
-*     }),
-*   }),
-* ]);
-*
-* const bill = await billRepo.create({ total: 250 });
-* // bill.billNumber → "BILL-2026-02-0001"
-* ```
-*
-* @example Custom generator function
-* ```typescript
-* const orderRepo = new Repository(OrderModel, [
-*   customIdPlugin({
-*     field: 'orderRef',
-*     generator: async (context) => {
-*       const region = context.data?.region || 'US';
-*       const seq = await getNextSequence('orders');
-*       return `ORD-${region}-${seq}`;
-*     },
-*   }),
-* ]);
-* ```
-*/
-/** Schema for the internal counters collection */
-const counterSchema = new mongoose.Schema({
-	_id: {
-		type: String,
-		required: true
-	},
-	seq: {
-		type: Number,
-		default: 0
-	}
-}, {
-	collection: "_mongokit_counters",
-	versionKey: false
-});
-/**
-* Get or create the Counter model on the given connection.
-* Falls back to the default mongoose connection if none is provided.
-* Lazy-init to avoid model registration errors if mongoose isn't connected yet.
-*/
-function getCounterModel(connection) {
-	const conn = connection ?? mongoose.connection;
-	if (conn.models._MongoKitCounter) return conn.models._MongoKitCounter;
-	return conn.model("_MongoKitCounter", counterSchema);
-}
-/**
-* Atomically increment and return the next sequence value for a given key.
-* Uses `findOneAndUpdate` with `upsert` + `$inc` — fully atomic even under
-* heavy concurrency.
-*
-* @param counterKey - Unique key identifying this counter (e.g., "Invoice" or "Invoice:2026-02")
-* @param increment - Value to increment by (default: 1)
-* @param connection - Mongoose connection to use (defaults to the default connection)
-* @param session - Optional client session. When provided, the counter bump
-*   participates in the caller's transaction — if the surrounding transaction
-*   aborts, the counter does NOT advance. Without a session, the bump commits
-*   immediately and is not rolled back if a sibling write fails.
-* @returns The next sequence number (after increment)
-*
-* @example
-* const seq = await getNextSequence('invoices');
-* // First call → 1, second → 2, ...
-*
-* @example Batch increment for createMany
-* const startSeq = await getNextSequence('invoices', 5);
-* // If current was 10, returns 15 (you use 11, 12, 13, 14, 15)
-*
-* @example Transactional counter bump
-* await withTransaction(conn, async (session) => {
-*   const seq = await getNextSequence('invoices', 1, conn, session);
-*   await invoiceRepo.create({ invoiceNumber: `INV-${seq}` }, { session });
-*   // if this throws, the counter is rolled back with the insert
-* });
-*/
-async function getNextSequence(counterKey, increment = 1, connection, session) {
-	const result = await getCounterModel(connection).findOneAndUpdate({ _id: counterKey }, { $inc: { seq: increment } }, {
-		upsert: true,
-		returnDocument: "after",
-		session
-	});
-	if (!result) throw new Error(`Failed to increment counter '${counterKey}'`);
-	return result.seq;
-}
-/**
-* Generator: Simple sequential counter.
-* Produces IDs like `INV-0001`, `INV-0002`, etc.
-*
-* Uses atomic MongoDB counters — safe under concurrency.
-*
-* @example
-* ```typescript
-* customIdPlugin({
-*   field: 'invoiceNumber',
-*   generator: sequentialId({ prefix: 'INV', model: InvoiceModel }),
-* })
-* ```
-*/
-function sequentialId(options) {
-	const { prefix, model, padding = 4, separator = "-", counterKey } = options;
-	const key = counterKey || model.modelName;
-	return async (context) => {
-		const seq = await getNextSequence(key, 1, context._counterConnection, context.session);
-		return `${prefix}${separator}${String(seq).padStart(padding, "0")}`;
-	};
-}
-/**
-* Generator: Date-partitioned sequential counter.
-* Counter resets per period — great for invoice/bill numbering.
-*
-* Produces IDs like:
-* - yearly:  `BILL-2026-0001`
-* - monthly: `BILL-2026-02-0001`
-* - daily:   `BILL-2026-02-20-0001`
-*
-* @example
-* ```typescript
-* customIdPlugin({
-*   field: 'billNumber',
-*   generator: dateSequentialId({
-*     prefix: 'BILL',
-*     model: BillModel,
-*     partition: 'monthly',
-*   }),
-* })
-* ```
-*/
-function dateSequentialId(options) {
-	const { prefix, model, partition = "monthly", padding = 4, separator = "-" } = options;
-	return async (context) => {
-		const now = /* @__PURE__ */ new Date();
-		const year = String(now.getFullYear());
-		const month = String(now.getMonth() + 1).padStart(2, "0");
-		const day = String(now.getDate()).padStart(2, "0");
-		let datePart;
-		let counterKey;
-		switch (partition) {
-			case "yearly":
-				datePart = year;
-				counterKey = `${model.modelName}:${year}`;
-				break;
-			case "daily":
-				datePart = `${year}${separator}${month}${separator}${day}`;
-				counterKey = `${model.modelName}:${year}-${month}-${day}`;
-				break;
-			default:
-				datePart = `${year}${separator}${month}`;
-				counterKey = `${model.modelName}:${year}-${month}`;
-				break;
-		}
-		const seq = await getNextSequence(counterKey, 1, context._counterConnection, context.session);
-		return `${prefix}${separator}${datePart}${separator}${String(seq).padStart(padding, "0")}`;
-	};
-}
-/**
-* Generator: Prefix + random alphanumeric suffix.
-* Does NOT require a database round-trip — purely in-memory.
-*
-* Produces IDs like: `USR_a7b3xk9m2p1q`
-*
-* Good for: user-facing IDs where ordering doesn't matter.
-* Not suitable for sequential numbering.
-*
-* @example
-* ```typescript
-* customIdPlugin({
-*   field: 'publicId',
-*   generator: prefixedId({ prefix: 'USR', length: 10 }),
-* })
-* ```
-*/
-function prefixedId(options) {
-	const { prefix, separator = "_", length = 12 } = options;
-	const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
-	return (_context) => {
-		let result = "";
-		const bytes = new Uint8Array(length);
-		if (typeof globalThis.crypto?.getRandomValues === "function") {
-			globalThis.crypto.getRandomValues(bytes);
-			for (let i = 0; i < length; i++) result += chars[bytes[i] % 36];
-		} else for (let i = 0; i < length; i++) result += chars[Math.floor(Math.random() * 36)];
-		return `${prefix}${separator}${result}`;
-	};
-}
-/**
-* Custom ID plugin — injects generated IDs into documents before creation.
-*
-* @param options - Configuration for ID generation
-* @returns Plugin instance
-*
-* @example
-* ```typescript
-* import { Repository, customIdPlugin, sequentialId } from '@classytic/mongokit';
-*
-* const invoiceRepo = new Repository(InvoiceModel, [
-*   customIdPlugin({
-*     field: 'invoiceNumber',
-*     generator: sequentialId({ prefix: 'INV', model: InvoiceModel }),
-*   }),
-* ]);
-*
-* const inv = await invoiceRepo.create({ amount: 100 });
-* console.log(inv.invoiceNumber); // "INV-0001"
-* ```
-*/
-function customIdPlugin(options) {
-	const fieldName = options.field || "customId";
-	const generateOnlyIfEmpty = options.generateOnlyIfEmpty !== false;
-	return {
-		name: "custom-id",
-		apply(repo) {
-			const repoConnection = repo.Model.db;
-			repo.on("before:create", async (context) => {
-				if (!context.data) return;
-				if (generateOnlyIfEmpty && context.data[fieldName]) return;
-				context._counterConnection = repoConnection;
-				context.data[fieldName] = await options.generator(context);
-			});
-			repo.on("before:createMany", async (context) => {
-				if (!context.dataArray) return;
-				context._counterConnection = repoConnection;
-				const docsNeedingIds = [];
-				for (const doc of context.dataArray) {
-					if (generateOnlyIfEmpty && doc[fieldName]) continue;
-					docsNeedingIds.push(doc);
-				}
-				if (docsNeedingIds.length === 0) return;
-				for (const doc of docsNeedingIds) doc[fieldName] = await options.generator({
-					...context,
-					data: doc
-				});
-			});
-		}
-	};
-}
-//#endregion
-//#region src/plugins/elastic.plugin.ts
-function elasticSearchPlugin(options) {
-	return {
-		name: "elastic-search",
-		apply(repo) {
-			if (!repo.registerMethod) throw new Error("[mongokit] elasticSearchPlugin requires methodRegistryPlugin to be registered first. Add methodRegistryPlugin() before elasticSearchPlugin() in your repository plugins array.");
-			repo.registerMethod("search", async function(searchQuery, searchOptions = {}) {
-				const { client, index, idField = "_id" } = options;
-				const limit = Math.min(Math.max(searchOptions.limit || 20, 1), 1e3);
-				const from = Math.max(searchOptions.from || 0, 0);
-				const esResponse = await client.search({
-					index,
-					body: {
-						query: searchQuery,
-						size: limit,
-						from
-					}
-				});
-				const hits = esResponse.hits?.hits || esResponse.body?.hits?.hits || [];
-				if (hits.length === 0) return {
-					docs: [],
-					total: 0,
-					limit,
-					from
-				};
-				const totalValue = esResponse.hits?.total?.value ?? esResponse.hits?.total ?? esResponse.body?.hits?.total?.value ?? esResponse.body?.hits?.total ?? 0;
-				const total = typeof totalValue === "number" ? totalValue : 0;
-				const docsOrder = /* @__PURE__ */ new Map();
-				const scores = /* @__PURE__ */ new Map();
-				const ids = [];
-				hits.forEach((hit, idx) => {
-					const docId = hit._source?.[idField] || hit[idField] || hit._id;
-					if (docId) {
-						const strId = String(docId);
-						docsOrder.set(strId, idx);
-						if (hit._score !== void 0) scores.set(strId, hit._score);
-						ids.push(strId);
-					}
-				});
-				if (ids.length === 0) return {
-					docs: [],
-					total,
-					limit,
-					from
-				};
-				const mongoIdField = repo.idField || "_id";
-				const mongoQuery = this.Model.find({ [mongoIdField]: { $in: ids } });
-				if (searchOptions.mongoOptions?.select) mongoQuery.select(searchOptions.mongoOptions.select);
-				if (searchOptions.mongoOptions?.populate) mongoQuery.populate(searchOptions.mongoOptions.populate);
-				if (searchOptions.mongoOptions?.lean !== false) mongoQuery.lean();
-				return {
-					docs: (await mongoQuery.exec()).sort((a, b) => {
-						const aId = String(a[mongoIdField]);
-						const bId = String(b[mongoIdField]);
-						return (docsOrder.get(aId) ?? Number.MAX_SAFE_INTEGER) - (docsOrder.get(bId) ?? Number.MAX_SAFE_INTEGER);
-					}).map((doc) => {
-						const strId = String(doc[mongoIdField]);
-						if (searchOptions.mongoOptions?.lean !== false) return {
-							...doc,
-							_score: scores.get(strId)
-						};
-						return doc;
-					}),
-					total,
-					limit,
-					from
-				};
-			});
-		}
-	};
-}
-//#endregion
-//#region src/plugins/field-filter.plugin.ts
-/**
-* Field filter plugin that restricts fields based on user context
-*
-* @example
-* const fieldPreset = {
-*   public: ['id', 'name'],
-*   authenticated: ['email'],
-*   admin: ['createdAt', 'internalNotes']
-* };
-*
-* const repo = new Repository(Model, [fieldFilterPlugin(fieldPreset)]);
-*/
-function fieldFilterPlugin(fieldPreset) {
-	return {
-		name: "fieldFilter",
-		apply(repo) {
-			const applyFieldFiltering = (context) => {
-				if (!fieldPreset) return;
-				const presetSelect = getFieldsForUser(context.context?.user || context.user, fieldPreset).join(" ");
-				if (context.select) context.select = `${presetSelect} ${context.select}`;
-				else context.select = presetSelect;
-			};
-			repo.on("before:getAll", applyFieldFiltering);
-			repo.on("before:findAll", applyFieldFiltering);
-			repo.on("before:getById", applyFieldFiltering);
-			repo.on("before:getByQuery", applyFieldFiltering);
-			repo.on("before:getOne", applyFieldFiltering);
-		}
-	};
-}
-//#endregion
-//#region src/plugins/method-registry.plugin.ts
-/**
-* Method registry plugin that enables dynamic method registration
-*/
-function methodRegistryPlugin() {
-	return {
-		name: "method-registry",
-		apply(repo) {
-			const registeredMethods = [];
-			/**
-			* Register a new method on the repository instance
-			*/
-			repo.registerMethod = (name, fn) => {
-				if (repo[name]) throw new Error(`Cannot register method '${name}': Method already exists on repository. Choose a different name or use a plugin that doesn't conflict.`);
-				if (!name || typeof name !== "string") throw new Error("Method name must be a non-empty string");
-				if (typeof fn !== "function") throw new Error(`Method '${name}' must be a function`);
-				repo[name] = fn.bind(repo);
-				registeredMethods.push(name);
-				repo.emit("method:registered", {
-					name,
-					fn
-				});
-			};
-			/**
-			* Check if a method is registered
-			*/
-			repo.hasMethod = (name) => typeof repo[name] === "function";
-			/**
-			* Get list of all dynamically registered methods
-			*/
-			repo.getRegisteredMethods = () => [...registeredMethods];
-		}
-	};
-}
-//#endregion
-//#region src/plugins/mongo-operations.plugin.ts
-/**
-* MongoDB Operations Plugin
-*
-* Adds MongoDB-specific operations to repositories.
-* Requires method-registry.plugin.js to be loaded first.
-*/
-/**
-* MongoDB operations plugin
-*
-* Adds MongoDB-specific atomic operations to repositories:
-* - upsert: Create or update document
-* - increment/decrement: Atomic numeric operations
-* - pushToArray/pullFromArray/addToSet: Array operations
-* - setField/unsetField/renameField: Field operations
-* - multiplyField: Multiply numeric field
-* - setMin/setMax: Conditional min/max updates
-*
-* @example Basic usage (no TypeScript autocomplete)
-* ```typescript
-* const repo = new Repository(ProductModel, [
-*   methodRegistryPlugin(),
-*   mongoOperationsPlugin(),
-* ]);
-*
-* // Works at runtime but TypeScript doesn't know about these methods
-* await (repo as any).increment(productId, 'views', 1);
-* await (repo as any).pushToArray(productId, 'tags', 'featured');
-* ```
-*
-* @example With TypeScript type safety (recommended)
-* ```typescript
-* import { Repository, mongoOperationsPlugin, methodRegistryPlugin } from '@classytic/mongokit';
-* import type { MongoOperationsMethods } from '@classytic/mongokit';
-*
-* class ProductRepo extends Repository<IProduct> {
-*   // Add your custom methods here
-* }
-*
-* // Create with type assertion to get autocomplete for plugin methods
-* type ProductRepoWithPlugins = ProductRepo & MongoOperationsMethods<IProduct>;
-*
-* const repo = new ProductRepo(ProductModel, [
-*   methodRegistryPlugin(),
-*   mongoOperationsPlugin(),
-* ]) as ProductRepoWithPlugins;
-*
-* // Now TypeScript provides autocomplete and type checking!
-* await repo.increment(productId, 'views', 1);
-* await repo.upsert({ sku: 'ABC' }, { name: 'Product', price: 99 });
-* await repo.pushToArray(productId, 'tags', 'featured');
-* ```
-*/
-function mongoOperationsPlugin() {
-	return {
-		name: "mongo-operations",
-		apply(repo) {
-			if (!repo.registerMethod) throw new Error("mongoOperationsPlugin requires methodRegistryPlugin. Add methodRegistryPlugin() before mongoOperationsPlugin() in plugins array.");
-			/**
-			* Update existing document or insert new one
-			*/
-			repo.registerMethod("upsert", async function(query, data, options = {}) {
-				return upsert(this.Model, query, data, options);
-			});
-			const validateAndUpdateNumeric = async function(id, field, value, operator, operationName, options) {
-				if (typeof value !== "number") throw createError(400, `${operationName} value must be a number`);
-				return this.update(id, { [operator]: { [field]: value } }, options);
-			};
-			/**
-			* Atomically increment numeric field
-			*/
-			repo.registerMethod("increment", async function(id, field, value = 1, options = {}) {
-				return validateAndUpdateNumeric.call(this, id, field, value, "$inc", "Increment", options);
-			});
-			/**
-			* Atomically decrement numeric field
-			*/
-			repo.registerMethod("decrement", async function(id, field, value = 1, options = {}) {
-				return validateAndUpdateNumeric.call(this, id, field, -value, "$inc", "Decrement", options);
-			});
-			const applyOperator = function(id, field, value, operator, options) {
-				return this.update(id, { [operator]: { [field]: value } }, options);
-			};
-			/**
-			* Push value to array field
-			*/
-			repo.registerMethod("pushToArray", async function(id, field, value, options = {}) {
-				return applyOperator.call(this, id, field, value, "$push", options);
-			});
-			/**
-			* Remove value from array field
-			*/
-			repo.registerMethod("pullFromArray", async function(id, field, value, options = {}) {
-				return applyOperator.call(this, id, field, value, "$pull", options);
-			});
-			/**
-			* Add value to array only if not already present (unique)
-			*/
-			repo.registerMethod("addToSet", async function(id, field, value, options = {}) {
-				return applyOperator.call(this, id, field, value, "$addToSet", options);
-			});
-			/**
-			* Set field value (alias for update with $set)
-			*/
-			repo.registerMethod("setField", async function(id, field, value, options = {}) {
-				return applyOperator.call(this, id, field, value, "$set", options);
-			});
-			/**
-			* Unset (remove) field from document
-			*/
-			repo.registerMethod("unsetField", async function(id, fields, options = {}) {
-				const unsetObj = (Array.isArray(fields) ? fields : [fields]).reduce((acc, field) => {
-					acc[field] = "";
-					return acc;
-				}, {});
-				return this.update(id, { $unset: unsetObj }, options);
-			});
-			/**
-			* Rename field in document
-			*/
-			repo.registerMethod("renameField", async function(id, oldName, newName, options = {}) {
-				return this.update(id, { $rename: { [oldName]: newName } }, options);
-			});
-			/**
-			* Multiply numeric field by value
-			*/
-			repo.registerMethod("multiplyField", async function(id, field, multiplier, options = {}) {
-				return validateAndUpdateNumeric.call(this, id, field, multiplier, "$mul", "Multiplier", options);
-			});
-			/**
-			* Set field to minimum value (only if current value is greater)
-			*/
-			repo.registerMethod("setMin", async function(id, field, value, options = {}) {
-				return applyOperator.call(this, id, field, value, "$min", options);
-			});
-			/**
-			* Set field to maximum value (only if current value is less)
-			*/
-			repo.registerMethod("setMax", async function(id, field, value, options = {}) {
-				return applyOperator.call(this, id, field, value, "$max", options);
-			});
-			/**
-			* Atomic update with multiple MongoDB operators in a single call
-			*
-			* Combines $inc, $set, $push, $pull, $addToSet, $unset, $setOnInsert, $min, $max, $mul, $rename
-			* into one atomic database operation.
-			*
-			* @example
-			* // Combine $inc + $set in one atomic call
-			* await repo.atomicUpdate(id, {
-			*   $inc: { views: 1, commentCount: 1 },
-			*   $set: { lastActiveAt: new Date() }
-			* });
-			*
-			* // Multiple operators: $inc + $set + $push
-			* await repo.atomicUpdate(id, {
-			*   $inc: { 'metrics.total': 1 },
-			*   $set: { updatedAt: new Date() },
-			*   $push: { history: { action: 'update', at: new Date() } }
-			* });
-			*
-			* // $push with $each modifier
-			* await repo.atomicUpdate(id, {
-			*   $push: { tags: { $each: ['featured', 'popular'] } },
-			*   $inc: { tagCount: 2 }
-			* });
-			*
-			* // With arrayFilters for positional updates
-			* await repo.atomicUpdate(id, {
-			*   $set: { 'items.$[elem].quantity': 5 }
-			* }, { arrayFilters: [{ 'elem._id': itemId }] });
-			*/
-			repo.registerMethod("atomicUpdate", async function(id, operators, options = {}) {
-				const validOperators = new Set([
-					"$inc",
-					"$set",
-					"$unset",
-					"$push",
-					"$pull",
-					"$addToSet",
-					"$pop",
-					"$rename",
-					"$min",
-					"$max",
-					"$mul",
-					"$setOnInsert",
-					"$bit",
-					"$currentDate"
-				]);
-				const keys = Object.keys(operators);
-				if (keys.length === 0) throw createError(400, "atomicUpdate requires at least one operator");
-				for (const key of keys) if (!validOperators.has(key)) throw createError(400, `Invalid update operator: '${key}'. Valid operators: ${[...validOperators].join(", ")}`);
-				return this.update(id, operators, options);
-			});
-		}
-	};
-}
-//#endregion
-//#region src/plugins/multi-tenant.plugin.ts
-/**
-* True when the op's policy target already has `tenantField` set by the
-* caller. Used to decide whether the plugin can safely skip injecting a
-* tenant scope rather than throwing on a missing context.
-*
-* - `data`       — `context.data[tenantField]` is present
-* - `dataArray`  — every row in `context.dataArray` has `tenantField`
-* - `query`      — `context.query[tenantField]` is present
-* - `filters`    — `context.filters[tenantField]` is present
-* - `operations` — every bulkWrite sub-op's filter/document has `tenantField`
-* - `none`       — unreachable (the hook isn't registered for these ops)
-*
-* For multi-row targets (`dataArray`, `operations`) we require EVERY row to
-* be stamped. Partial stamping is ambiguous (we have no resolver value to
-* fill in the gaps) and is safer to treat as "not stamped" so the caller
-* either stamps all rows or supplies a context/resolver.
-*/
-function payloadHasTenantField(context, policyKey, tenantField) {
-	switch (policyKey) {
-		case "data": return context.data?.[tenantField] != null;
-		case "dataArray": {
-			const arr = context.dataArray;
-			if (!Array.isArray(arr) || arr.length === 0) return false;
-			return arr.every((row) => row && row[tenantField] != null);
-		}
-		case "query": return context.query?.[tenantField] != null;
-		case "filters": return context.filters?.[tenantField] != null;
-		case "operations": {
-			const ops = context.operations;
-			if (!Array.isArray(ops) || ops.length === 0) return false;
-			return ops.every((subOp) => {
-				for (const key of [
-					"updateOne",
-					"updateMany",
-					"deleteOne",
-					"deleteMany",
-					"replaceOne"
-				]) {
-					const body = subOp[key];
-					if (body) return body.filter?.[tenantField] != null;
-				}
-				const ins = subOp.insertOne;
-				if (ins) return ins.document?.[tenantField] != null;
-				return false;
-			});
-		}
-		default: return false;
-	}
-}
-function multiTenantPlugin(options = {}) {
-	const { tenantField = "organizationId", contextKey = "organizationId", required = true, skipOperations = [], skipWhen, resolveContext, fieldType = "string", allowDataInjection = true } = options;
-	const extraOps = [{
-		op: "getDeleted",
-		policyKey: "filters"
-	}];
-	return {
-		name: "multi-tenant",
-		apply(repo) {
-			const allOps = [...ALL_OPERATIONS.map((op) => ({
-				op,
-				policyKey: OP_REGISTRY[op].policyKey
-			})), ...extraOps];
-			for (const { op, policyKey } of allOps) {
-				if (skipOperations.includes(op)) continue;
-				if (policyKey === "none") continue;
-				repo.on(`before:${op}`, (context) => {
-					if (skipWhen?.(context, op)) return;
-					let tenantId = context[contextKey];
-					if (!tenantId && resolveContext) {
-						tenantId = resolveContext();
-						if (tenantId) context[contextKey] = tenantId;
-					}
-					if (!tenantId && allowDataInjection && payloadHasTenantField(context, policyKey, tenantField)) return;
-					if (!tenantId && required) throw new Error(`[mongokit] Multi-tenant: Missing '${contextKey}' in context for '${op}'. Pass it via options or set required: false.`);
-					if (!tenantId) return;
-					const castId = fieldType === "objectId" ? new mongoose.Types.ObjectId(tenantId) : tenantId;
-					switch (policyKey) {
-						case "filters":
-							context.filters = {
-								...context.filters,
-								[tenantField]: castId
-							};
-							break;
-						case "query":
-							context.query = {
-								...context.query,
-								[tenantField]: castId
-							};
-							break;
-						case "data":
-							if (context.data) context.data[tenantField] = castId;
-							break;
-						case "dataArray":
-							if (context.dataArray) {
-								for (const doc of context.dataArray) if (doc && typeof doc === "object") doc[tenantField] = castId;
-							}
-							break;
-						case "operations":
-							if (context.operations) {
-								const ops = context.operations;
-								for (const subOp of ops) {
-									for (const key of [
-										"updateOne",
-										"updateMany",
-										"deleteOne",
-										"deleteMany",
-										"replaceOne"
-									]) {
-										const opBody = subOp[key];
-										if (opBody?.filter) opBody.filter = {
-											...opBody.filter,
-											[tenantField]: castId
-										};
-									}
-									const insertBody = subOp.insertOne;
-									if (insertBody?.document) insertBody.document[tenantField] = castId;
-								}
-							}
-							break;
-					}
-				}, { priority: HOOK_PRIORITY$1.POLICY });
-			}
-		}
-	};
-}
-//#endregion
-//#region src/plugins/observability.plugin.ts
-/**
-* Observability Plugin
-*
-* Adds operation timing, structured metrics, and APM hook points.
-* Works with any monitoring system — just provide an onMetric callback.
-*
-* @example
-* ```typescript
-* const repo = new Repository(User, [
-*   observabilityPlugin({
-*     onMetric: (metric) => {
-*       // Send to DataDog, New Relic, OpenTelemetry, or console
-*       console.log(`${metric.operation} took ${metric.durationMs}ms`);
-*       statsd.histogram('mongokit.operation', metric.durationMs, { op: metric.operation });
-*     },
-*   }),
-* ]);
-* ```
-*/
-const DEFAULT_OPS = ALL_OPERATIONS;
-const timers = /* @__PURE__ */ new WeakMap();
-function observabilityPlugin(options) {
-	const { onMetric, slowThresholdMs } = options;
-	const ops = options.operations ?? DEFAULT_OPS;
-	return {
-		name: "observability",
-		apply(repo) {
-			for (const op of ops) {
-				repo.on(`before:${op}`, (context) => {
-					timers.set(context, performance.now());
-				}, { priority: 300 });
-				repo.on(`after:${op}`, ({ context }) => {
-					const start = timers.get(context);
-					if (start == null) return;
-					const durationMs = Math.round((performance.now() - start) * 100) / 100;
-					timers.delete(context);
-					if (slowThresholdMs != null && durationMs < slowThresholdMs) return;
-					onMetric({
-						operation: op,
-						model: context.model || repo.model,
-						durationMs,
-						success: true,
-						startedAt: new Date(Date.now() - durationMs),
-						userId: context.user?._id?.toString() || context.user?.id?.toString(),
-						organizationId: context.organizationId?.toString()
-					});
-				});
-				repo.on(`error:${op}`, ({ context, error }) => {
-					const start = timers.get(context);
-					if (start == null) return;
-					const durationMs = Math.round((performance.now() - start) * 100) / 100;
-					timers.delete(context);
-					onMetric({
-						operation: op,
-						model: context.model || repo.model,
-						durationMs,
-						success: false,
-						error: error.message,
-						startedAt: new Date(Date.now() - durationMs),
-						userId: context.user?._id?.toString() || context.user?.id?.toString(),
-						organizationId: context.organizationId?.toString()
-					});
-				});
-			}
-		}
-	};
-}
-//#endregion
-//#region src/plugins/soft-delete.plugin.ts
-/**
-* Build filter condition based on filter mode
-*/
-function buildDeletedFilter(deletedField, filterMode, includeDeleted) {
-	if (includeDeleted) return {};
-	if (filterMode === "exists") return { [deletedField]: { $exists: false } };
-	return { [deletedField]: null };
-}
-/**
-* Build filter condition for finding deleted documents
-*/
-function buildGetDeletedFilter(deletedField, filterMode) {
-	if (filterMode === "exists") return { [deletedField]: {
-		$exists: true,
-		$ne: null
-	} };
-	return { [deletedField]: { $ne: null } };
-}
-/**
-* Soft delete plugin
-*
-* @example Basic usage
-* ```typescript
-* const repo = new Repository(Model, [
-*   softDeletePlugin({ deletedField: 'deletedAt' })
-* ]);
-*
-* // Delete (soft)
-* await repo.delete(id);
-*
-* // Restore
-* await repo.restore(id);
-*
-* // Get deleted documents
-* await repo.getDeleted({ page: 1, limit: 20 });
-* ```
-*
-* @example With null filter mode (for schemas with default: null)
-* ```typescript
-* // Schema: { deletedAt: { type: Date, default: null } }
-* const repo = new Repository(Model, [
-*   softDeletePlugin({
-*     deletedField: 'deletedAt',
-*     filterMode: 'null', // default - works with default: null
-*   })
-* ]);
-* ```
-*
-* @example With TTL for auto-cleanup
-* ```typescript
-* const repo = new Repository(Model, [
-*   softDeletePlugin({
-*     deletedField: 'deletedAt',
-*     ttlDays: 30, // Auto-delete after 30 days
-*   })
-* ]);
-* ```
-*/
-function softDeletePlugin(options = {}) {
-	const deletedField = options.deletedField || "deletedAt";
-	const deletedByField = options.deletedByField || "deletedBy";
-	const filterMode = options.filterMode || "null";
-	const addRestoreMethod = options.addRestoreMethod !== false;
-	const addGetDeletedMethod = options.addGetDeletedMethod !== false;
-	const ttlDays = options.ttlDays;
-	return {
-		name: "softDelete",
-		apply(repo) {
-			try {
-				const schemaPaths = repo.Model.schema.paths;
-				for (const [pathName, schemaType] of Object.entries(schemaPaths)) {
-					if (pathName === "_id" || pathName === deletedField) continue;
-					if (schemaType.options?.unique) warn(`[softDeletePlugin] Field '${pathName}' on model '${repo.Model.modelName}' has a unique index. With soft-delete enabled, deleted documents will block new documents with the same '${pathName}'. Fix: change to a compound partial index — { ${pathName}: 1 }, { unique: true, partialFilterExpression: { ${deletedField}: null } }`);
-				}
-			} catch (err) {
-				warn(`[softDeletePlugin] Schema introspection failed for ${repo.Model.modelName}: ${err instanceof Error ? err.message : String(err)}`);
-			}
-			if (ttlDays !== void 0 && ttlDays > 0) {
-				const ttlSeconds = ttlDays * 24 * 60 * 60;
-				repo.Model.collection.createIndex({ [deletedField]: 1 }, {
-					expireAfterSeconds: ttlSeconds,
-					partialFilterExpression: { [deletedField]: { $type: "date" } }
-				}).catch((err) => {
-					if (err.code !== 85 && err.code !== 86 && !err.message.includes("already exists")) warn(`[softDeletePlugin] Failed to create TTL index: ${err.message}`);
-				});
-			}
-			repo.on("before:delete", async (context) => {
-				if (context.deleteMode === "hard") return;
-				if (options.soft !== false) {
-					const updateData = { [deletedField]: /* @__PURE__ */ new Date() };
-					if (context.user) updateData[deletedByField] = context.user._id || context.user.id;
-					const deleteQuery = {
-						[repo.idField || "_id"]: context.id,
-						...context.query || {}
-					};
-					if (!await repo.Model.findOneAndUpdate(deleteQuery, updateData, { session: context.session })) {
-						const error = /* @__PURE__ */ new Error(`Document with id '${context.id}' not found`);
-						error.status = 404;
-						throw error;
-					}
-					context.softDeleted = true;
-				}
-			}, { priority: HOOK_PRIORITY$1.POLICY });
-			const injectDeleteFilterToFilters = (context) => {
-				if (options.soft !== false) {
-					const deleteFilter = buildDeletedFilter(deletedField, filterMode, !!context.includeDeleted);
-					if (Object.keys(deleteFilter).length > 0) context.filters = {
-						...context.filters || {},
-						...deleteFilter
-					};
-				}
-			};
-			const injectDeleteFilterToQuery = (context) => {
-				if (options.soft !== false) {
-					const deleteFilter = buildDeletedFilter(deletedField, filterMode, !!context.includeDeleted);
-					if (Object.keys(deleteFilter).length > 0) context.query = {
-						...context.query || {},
-						...deleteFilter
-					};
-				}
-			};
-			const SOFT_DELETE_SPECIAL = new Set([
-				"updateMany",
-				"deleteMany",
-				"bulkWrite"
-			]);
-			for (const op of ALL_OPERATIONS) {
-				if (SOFT_DELETE_SPECIAL.has(op)) continue;
-				const desc = OP_REGISTRY[op];
-				const isFilterableMutation = op === "findOneAndUpdate";
-				if (desc.mutates && !isFilterableMutation) continue;
-				if (desc.policyKey === "filters") repo.on(`before:${op}`, injectDeleteFilterToFilters, { priority: HOOK_PRIORITY$1.POLICY });
-				else if (desc.policyKey === "query") repo.on(`before:${op}`, injectDeleteFilterToQuery, { priority: HOOK_PRIORITY$1.POLICY });
-			}
-			repo.on("before:updateMany", (context) => {
-				if (options.soft !== false) {
-					const deleteFilter = buildDeletedFilter(deletedField, filterMode, !!context.includeDeleted);
-					if (Object.keys(deleteFilter).length > 0) context.query = {
-						...context.query || {},
-						...deleteFilter
-					};
-				}
-			}, { priority: HOOK_PRIORITY$1.POLICY });
-			repo.on("before:deleteMany", async (context) => {
-				if (context.deleteMode === "hard") return;
-				if (options.soft !== false) {
-					const deleteFilter = buildDeletedFilter(deletedField, filterMode, false);
-					const finalQuery = {
-						...context.query || {},
-						...deleteFilter
-					};
-					const updateRes = await repo.Model.updateMany(finalQuery, { $set: { [deletedField]: /* @__PURE__ */ new Date() } }, { session: context.session });
-					context.softDeleted = true;
-					context.softDeletedCount = updateRes?.modifiedCount ?? 0;
-				}
-			}, { priority: HOOK_PRIORITY$1.POLICY });
-			if (addRestoreMethod) {
-				const restoreMethod = async function(id, restoreOptions = {}) {
-					const context = await this._buildContext("restore", {
-						id,
-						...restoreOptions
-					});
-					const updateData = {
-						[deletedField]: null,
-						[deletedByField]: null
-					};
-					const restoreQuery = {
-						_id: id,
-						...context.query || {}
-					};
-					const result = await this.Model.findOneAndUpdate(restoreQuery, { $set: updateData }, {
-						returnDocument: "after",
-						session: restoreOptions.session
-					});
-					if (!result) {
-						const error = /* @__PURE__ */ new Error(`Document with id '${id}' not found`);
-						error.status = 404;
-						throw error;
-					}
-					await this.emitAsync("after:restore", {
-						context,
-						result
-					});
-					return result;
-				};
-				if (typeof repo.registerMethod === "function") repo.registerMethod("restore", restoreMethod);
-				else repo.restore = restoreMethod.bind(repo);
-			}
-			if (addGetDeletedMethod) {
-				const getDeletedMethod = async function(params = {}, getDeletedOptions = {}) {
-					const context = await this._buildContext("getDeleted", {
-						...params,
-						...getDeletedOptions
-					});
-					const deletedFilter = buildGetDeletedFilter(deletedField, filterMode);
-					const combinedFilters = {
-						...params.filters || {},
-						...deletedFilter,
-						...context.filters || {},
-						...context.query || {}
-					};
-					const page = params.page || 1;
-					const limit = params.limit || 20;
-					const skip = (page - 1) * limit;
-					let sortSpec = { [deletedField]: -1 };
-					if (params.sort) if (typeof params.sort === "string") {
-						const sortOrder = params.sort.startsWith("-") ? -1 : 1;
-						sortSpec = { [params.sort.startsWith("-") ? params.sort.substring(1) : params.sort]: sortOrder };
-					} else sortSpec = params.sort;
-					let query = this.Model.find(combinedFilters).sort(sortSpec).skip(skip).limit(limit);
-					if (getDeletedOptions.session) query = query.session(getDeletedOptions.session);
-					if (getDeletedOptions.select) {
-						const selectValue = Array.isArray(getDeletedOptions.select) ? getDeletedOptions.select.join(" ") : getDeletedOptions.select;
-						query = query.select(selectValue);
-					}
-					if (getDeletedOptions.populate) {
-						const populateSpec = getDeletedOptions.populate;
-						if (typeof populateSpec === "string") query = query.populate(populateSpec.split(",").map((p) => p.trim()));
-						else if (Array.isArray(populateSpec)) query = query.populate(populateSpec);
-						else query = query.populate(populateSpec);
-					}
-					if (getDeletedOptions.lean !== false) query = query.lean();
-					const [docs, total] = await Promise.all([query.exec(), this.Model.countDocuments(combinedFilters)]);
-					const pages = Math.ceil(total / limit);
-					return {
-						method: "offset",
-						docs,
-						page,
-						limit,
-						total,
-						pages,
-						hasNext: page < pages,
-						hasPrev: page > 1
-					};
-				};
-				if (typeof repo.registerMethod === "function") repo.registerMethod("getDeleted", getDeletedMethod);
-				else repo.getDeleted = getDeletedMethod.bind(repo);
-			}
-		}
-	};
-}
-//#endregion
-//#region src/plugins/subdocument.plugin.ts
-/**
-* Subdocument plugin for managing nested arrays
-*
-* @example
-* const repo = new Repository(Model, [
-*   methodRegistryPlugin(),
-*   subdocumentPlugin(),
-* ]);
-*
-* await repo.addSubdocument(parentId, 'items', { name: 'Item 1' });
-* await repo.updateSubdocument(parentId, 'items', itemId, { name: 'Updated Item' });
-*/
-function subdocumentPlugin() {
-	return {
-		name: "subdocument",
-		apply(repo) {
-			if (!repo.registerMethod) throw new Error("subdocumentPlugin requires methodRegistryPlugin");
-			/**
-			* Add subdocument to array
-			*/
-			repo.registerMethod("addSubdocument", async function(parentId, arrayPath, subData, options = {}) {
-				return this.update(parentId, { $push: { [arrayPath]: subData } }, options);
-			});
-			/**
-			* Get subdocument from array
-			*/
-			repo.registerMethod("getSubdocument", async function(parentId, arrayPath, subId, options = {}) {
-				return this._executeQuery(async (Model) => {
-					const parent = await Model.findById(parentId).session(options.session).exec();
-					if (!parent) throw createError(404, "Parent not found");
-					const arrayField = parent[arrayPath];
-					if (!arrayField || typeof arrayField.id !== "function") throw createError(404, "Array field not found");
-					const sub = arrayField.id(subId);
-					if (!sub) throw createError(404, "Subdocument not found");
-					return options.lean && typeof sub.toObject === "function" ? sub.toObject() : sub;
-				});
-			});
-			/**
-			* Update subdocument in array
-			*/
-			repo.registerMethod("updateSubdocument", async function(parentId, arrayPath, subId, updateData, options = {}) {
-				return this._executeQuery(async (Model) => {
-					const query = {
-						_id: parentId,
-						[`${arrayPath}._id`]: subId
-					};
-					const update = { $set: { [`${arrayPath}.$`]: {
-						...updateData,
-						_id: subId
-					} } };
-					const result = await Model.findOneAndUpdate(query, update, {
-						returnDocument: "after",
-						runValidators: true,
-						session: options.session
-					}).exec();
-					if (!result) throw createError(404, "Parent or subdocument not found");
-					return result;
-				});
-			});
-			/**
-			* Delete subdocument from array
-			*/
-			repo.registerMethod("deleteSubdocument", async function(parentId, arrayPath, subId, options = {}) {
-				return this.update(parentId, { $pull: { [arrayPath]: { _id: subId } } }, options);
-			});
-		}
-	};
-}
-//#endregion
-//#region src/plugins/tenant-context.ts
-/**
-* Request-scoped tenant context via AsyncLocalStorage.
-*
-* The multi-tenant plugin already accepts a `resolveContext` callback for
-* reading tenant ID from an external store. This helper wraps Node's
-* `AsyncLocalStorage` into a tiny, batteries-included API so apps don't need
-* to wire the plumbing by hand — a common source of cross-tenant leaks.
-*
-* @example
-*   import { createTenantContext, multiTenantPlugin } from '@classytic/mongokit';
-*
-*   const tenantContext = createTenantContext();
-*
-*   // In your HTTP middleware (Express / Fastify / NestJS):
-*   app.use((req, _res, next) => {
-*     tenantContext.run({ tenantId: req.auth.organizationId }, next);
-*   });
-*
-*   // In your repository definition:
-*   const repo = new Repository(Invoice, [
-*     multiTenantPlugin({
-*       tenantField: 'organizationId',
-*       resolveContext: () => tenantContext.getTenantId(),
-*     }),
-*   ]);
-*
-*   // In your handler — no need to pass organizationId manually:
-*   await repo.getAll({ filters: { status: 'paid' } });
-*/
-function createTenantContext() {
-	const storage = new AsyncLocalStorage();
-	return {
-		storage,
-		run(store, fn) {
-			return storage.run(store, fn);
-		},
-		getStore() {
-			return storage.getStore();
-		},
-		getTenantId() {
-			return storage.getStore()?.tenantId;
-		},
-		requireTenantId() {
-			const id = storage.getStore()?.tenantId;
-			if (!id) throw new Error("[mongokit] No tenant context active. Wrap the request in tenantContext.run({ tenantId }, fn).");
-			return id;
-		}
-	};
-}
-//#endregion
-//#region src/plugins/timestamp.plugin.ts
-/**
-* Timestamp plugin that auto-injects timestamps
-*
-* @example
-* const repo = new Repository(Model, [timestampPlugin()]);
-*/
-function timestampPlugin() {
-	return {
-		name: "timestamp",
-		apply(repo) {
-			repo.on("before:create", (context) => {
-				if (!context.data) return;
-				const now = /* @__PURE__ */ new Date();
-				if (!context.data.createdAt) context.data.createdAt = now;
-				if (!context.data.updatedAt) context.data.updatedAt = now;
-			});
-			repo.on("before:update", (context) => {
-				if (!context.data) return;
-				context.data.updatedAt = /* @__PURE__ */ new Date();
-			});
-			repo.on("before:findOneAndUpdate", (context) => {
-				if (!context.data) return;
-				const now = /* @__PURE__ */ new Date();
-				if (Array.isArray(context.data)) return;
-				const update = context.data;
-				if (Object.keys(update).some((k) => k.startsWith("$"))) {
-					const set = update.$set || {};
-					set.updatedAt = now;
-					update.$set = set;
-					const setOnInsert = update.$setOnInsert || {};
-					if (!("createdAt" in setOnInsert)) setOnInsert.createdAt = now;
-					update.$setOnInsert = setOnInsert;
-				} else update.updatedAt = now;
-			});
-		}
-	};
-}
-//#endregion
-//#region src/plugins/validation-chain.plugin.ts
-/**
-* Validation chain plugin
-*
-* @example
-* const repo = new Repository(Model, [
-*   validationChainPlugin([
-*     requireField('email'),
-*     uniqueField('email', 'Email already exists'),
-*     blockIf('no-delete-admin', ['delete'], ctx => ctx.data?.role === 'admin', 'Cannot delete admin'),
-*   ])
-* ]);
-*/
-function validationChainPlugin(validators = [], options = {}) {
-	const { stopOnFirstError = true } = options;
-	validators.forEach((v, idx) => {
-		if (!v.name || typeof v.name !== "string") throw new Error(`Validator at index ${idx} missing 'name' (string)`);
-		if (typeof v.validate !== "function") throw new Error(`Validator '${v.name}' missing 'validate' function`);
-	});
-	const validatorsByOperation = {
-		create: [],
-		update: [],
-		findOneAndUpdate: [],
-		delete: [],
-		createMany: []
-	};
-	const allOperationsValidators = [];
-	validators.forEach((v) => {
-		if (!v.operations || v.operations.length === 0) allOperationsValidators.push(v);
-		else v.operations.forEach((op) => {
-			if (validatorsByOperation[op]) validatorsByOperation[op].push(v);
-		});
-	});
-	return {
-		name: "validation-chain",
-		apply(repo) {
-			const getValidatorsForOperation = (operation) => {
-				const specific = validatorsByOperation[operation] || [];
-				return [...allOperationsValidators, ...specific];
-			};
-			const runValidators = async (operation, context) => {
-				const operationValidators = getValidatorsForOperation(operation);
-				const errors = [];
-				for (const validator of operationValidators) try {
-					await validator.validate(context, repo);
-				} catch (error) {
-					if (stopOnFirstError) throw error;
-					errors.push({
-						validator: validator.name,
-						error: error.message || String(error)
-					});
-				}
-				if (errors.length > 0) {
-					const err = createError(400, `Validation failed: ${errors.map((e) => `[${e.validator}] ${e.error}`).join("; ")}`);
-					err.validationErrors = errors;
-					throw err;
-				}
-			};
-			repo.on("before:create", async (context) => runValidators("create", context));
-			repo.on("before:createMany", async (context) => runValidators("createMany", context));
-			repo.on("before:update", async (context) => runValidators("update", context));
-			repo.on("before:findOneAndUpdate", async (context) => runValidators("findOneAndUpdate", context));
-			repo.on("before:delete", async (context) => runValidators("delete", context));
-		}
-	};
-}
-/**
-* Block operation if condition is true
-*
-* @example
-* blockIf('block-library', ['delete'], ctx => ctx.data?.managed, 'Cannot delete managed records')
-*/
-function blockIf(name, operations, condition, errorMessage) {
-	return {
-		name,
-		operations,
-		validate: (context) => {
-			if (condition(context)) throw createError(403, errorMessage);
-		}
-	};
-}
-/**
-* Require a field to be present
-*/
-function requireField(field, operations = ["create"]) {
-	return {
-		name: `require-${field}`,
-		operations,
-		validate: (context) => {
-			if (!context.data || context.data[field] === void 0 || context.data[field] === null) throw createError(400, `Field '${field}' is required`);
-		}
-	};
-}
-/**
-* Auto-inject a value if not present
-*/
-function autoInject(field, getter, operations = ["create"]) {
-	return {
-		name: `auto-inject-${field}`,
-		operations,
-		validate: (context) => {
-			if (context.data && !(field in context.data)) {
-				const value = getter(context);
-				if (value !== null && value !== void 0) context.data[field] = value;
-			}
-		}
-	};
-}
-/**
-* Make a field immutable (cannot be updated)
-*/
-function immutableField(field) {
-	return {
-		name: `immutable-${field}`,
-		operations: ["update"],
-		validate: (context) => {
-			if (context.data && field in context.data) throw createError(400, `Field '${field}' cannot be modified`);
-		}
-	};
-}
-/**
-* Ensure field value is unique
-*/
-function uniqueField(field, errorMessage) {
-	return {
-		name: `unique-${field}`,
-		operations: ["create", "update"],
-		validate: async (context, repo) => {
-			if (!context.data?.[field]) return;
-			if (!repo) {
-				warn(`[mongokit] uniqueField('${field}'): repo not available, skipping uniqueness check`);
-				return;
-			}
-			const query = { [field]: context.data[field] };
-			const getByQuery = repo.getByQuery;
-			if (typeof getByQuery !== "function") {
-				warn(`[mongokit] uniqueField('${field}'): getByQuery not available on repo, skipping uniqueness check`);
-				return;
-			}
-			const idKey = repo.idField || "_id";
-			const existing = await getByQuery.call(repo, query, {
-				select: idKey,
-				lean: true,
-				throwOnNotFound: false
-			});
-			if (existing && String(existing[idKey]) !== String(context.id)) throw createError(409, errorMessage || `${field} already exists`);
-		}
-	};
-}
-//#endregion
-export { AuditTrailQuery as A, cachePlugin as C, withTransaction as D, isTransactionUnsupported as E, MUTATING_OPERATIONS as F, OP_REGISTRY as I, READ_OPERATIONS as L, auditLogPlugin as M, aggregateHelpersPlugin as N, AggregationBuilder as O, ALL_OPERATIONS as P, operationsByPolicyKey as R, cascadePlugin as S, Repository as T, customIdPlugin as _, uniqueField as a, prefixedId as b, createTenantContext as c, observabilityPlugin as d, multiTenantPlugin as f, elasticSearchPlugin as g, fieldFilterPlugin as h, requireField as i, auditTrailPlugin as j, batchOperationsPlugin as k, subdocumentPlugin as l, methodRegistryPlugin as m, blockIf as n, validationChainPlugin as o, mongoOperationsPlugin as p, immutableField as r, timestampPlugin as s, autoInject as t, softDeletePlugin as u, dateSequentialId as v, HOOK_PRIORITY$1 as w, sequentialId as x, getNextSequence as y };