@rpcbase/db 0.135.0 → 0.136.0

package/dist/index.js

@@ -2,12 +2,14 @@ import { buildAbility, buildAbilityFromSession, can, getAccessibleByQuery, getRe
 import { a as makeZE164Phone, c as buildLocaleFallbackChain, d as zI18nString, f as zLocalizedString, i as E164_PHONE_REGEX, l as resolveLocalizedString, n as extendZod, o as zE164Phone, r as E164_PHONE_OR_EMPTY_REGEX, s as LANGUAGE_CODE_REGEX, t as z, u as withLocalizedStringFallback } from "./zod-DSnhyNso.js";
 import "./model.js";
 import { getMongoDirectConnection, getMongoUrl } from "./mongo.js";
+import { ForbiddenError, subject } from "@casl/ability";
 import { accessibleBy, accessibleRecordsPlugin } from "@casl/mongoose";
 import mongoose, { Schema as Schema$1, Types, default as mongoose$1 } from "mongoose";
 import { z as z$1 } from "zod";
 import { SUBSCRIPTION_CHANGE_DIRECTIONS, SUBSCRIPTION_EVENT_TYPES, SUBSCRIPTION_INTERVAL_UNITS, SUBSCRIPTION_SCOPES, SUBSCRIPTION_STATUSES, SUBSCRIPTION_TYPES } from "@rpcbase/billing";
 import { createHmac, timingSafeEqual } from "node:crypto";
 import assert from "assert";
+import { AsyncLocalStorage } from "node:async_hooks";
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
@@ -1470,16 +1472,16 @@ var paginateMongoQuery = async (query, pagination, options) => {
 };
 //#endregion
 //#region src/pagination/mongoPaginationPlugin.ts
-var getQueryOptions$1 = (query) => {
+var getQueryOptions = (query) => {
 	if (!query || typeof query !== "object") return void 0;
 	if (!("getOptions" in query) || typeof query.getOptions !== "function") return void 0;
 	return query.getOptions();
 };
 var getPaginationFromOptions = (query) => {
-	return getQueryOptions$1(query)?.pagination;
+	return getQueryOptions(query)?.pagination;
 };
 var getCursorFromOptions = (query) => {
-	return getQueryOptions$1(query)?.paginationCursor;
+	return getQueryOptions(query)?.paginationCursor;
 };
 var mongoPaginationPlugin = (schema, pluginOptions) => {
 	schema.query.paginate = async function(pagination, options) {
@@ -1574,7 +1576,643 @@ var getTenantDbName = (tenantId, env = process.env) => {
 	return `${getAppName$1(env)}-${tenantId.trim()}-db`;
 };
 //#endregion
+//#region src/acl/mongooseAclUtils.ts
+var isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+var mergeMongoQuery = (left, right) => {
+	if (left != null && !isRecord(left)) throw new TypeError("ACL-protected MongoDB filters must be objects.");
+	const leftQuery = left ?? {};
+	if (Object.keys(leftQuery).length === 0) return right;
+	if (Object.keys(right).length === 0) return leftQuery;
+	return { $and: [leftQuery, right] };
+};
+var cloneMongoValue = (value) => {
+	if (value instanceof Date) return new Date(value.getTime());
+	if (Buffer.isBuffer(value)) return Buffer.from(value);
+	if (Array.isArray(value)) return value.map((entry) => cloneMongoValue(entry));
+	if (!isRecord(value)) return value;
+	const prototype = Object.getPrototypeOf(value);
+	if (prototype !== Object.prototype && prototype !== null) return value;
+	const copy = Object.create(prototype);
+	for (const [key, entry] of Object.entries(value)) copy[key] = cloneMongoValue(entry);
+	return copy;
+};
+var castMongoQuery = (model, query) => {
+	const casted = model.find(cloneMongoValue(query)).cast(model);
+	if (!isRecord(casted)) throw new TypeError(`Mongoose returned an invalid casted query for model "${model.modelName}".`);
+	return casted;
+};
+//#endregion
+//#region src/acl/mongooseAclAggregate.ts
+var allowedAggregateStages = /* @__PURE__ */ new Set([
+	"$addFields",
+	"$bucket",
+	"$bucketAuto",
+	"$count",
+	"$densify",
+	"$facet",
+	"$fill",
+	"$geoNear",
+	"$graphLookup",
+	"$group",
+	"$limit",
+	"$lookup",
+	"$match",
+	"$project",
+	"$redact",
+	"$replaceRoot",
+	"$replaceWith",
+	"$sample",
+	"$search",
+	"$set",
+	"$setWindowFields",
+	"$skip",
+	"$sort",
+	"$sortByCount",
+	"$unionWith",
+	"$unset",
+	"$unwind",
+	"$vectorSearch"
+]);
+var injectAggregateMatch = (pipeline, match) => {
+	if (Object.keys(match).length === 0) return;
+	if (pipeline.length === 0) {
+		pipeline.unshift({ $match: match });
+		return;
+	}
+	const first = pipeline[0];
+	if (!isRecord(first)) {
+		pipeline.unshift({ $match: match });
+		return;
+	}
+	if ("$geoNear" in first) {
+		const geoNear = first.$geoNear;
+		if (isRecord(geoNear)) {
+			geoNear.query = mergeMongoQuery(geoNear.query, match);
+			return;
+		}
+	}
+	if ("$search" in first || "$vectorSearch" in first) {
+		pipeline.splice(1, 0, { $match: match });
+		return;
+	}
+	pipeline.unshift({ $match: match });
+};
+var containsSearchMetadataReference = (value) => {
+	if (typeof value === "string") return value === "$$SEARCH_META" || value.startsWith("$$SEARCH_META.");
+	if (Array.isArray(value)) return value.some(containsSearchMetadataReference);
+	if (!isRecord(value)) return false;
+	return Object.values(value).some(containsSearchMetadataReference);
+};
+var getModelCollectionName$2 = (model) => {
+	const collection = model.collection;
+	if (typeof collection.collectionName === "string") return collection.collectionName;
+	if (typeof collection.name === "string") return collection.name;
+	return null;
+};
+var resolveAggregateModel = (sourceModel, collectionName) => {
+	const candidates = /* @__PURE__ */ new Map();
+	const connectionModels = sourceModel.db?.models ?? {};
+	for (const model of [...Object.values(connectionModels), ...Object.values(mongoose$1.models)]) {
+		const typedModel = model;
+		if (getModelCollectionName$2(typedModel) !== collectionName) continue;
+		candidates.set(typedModel.modelName, typedModel);
+	}
+	if (candidates.size === 0) throw new Error(`ACL driver cannot access collection "${collectionName}" because no registered Mongoose model maps to it.`);
+	if (candidates.size > 1) throw new Error(`ACL driver cannot resolve collection "${collectionName}" unambiguously.`);
+	return [...candidates.values()][0];
+};
+var assertAllowedAggregateStage = (stage) => {
+	const stageNames = Object.keys(stage);
+	if (stageNames.length !== 1) throw new Error("ACL-protected aggregates require exactly one operator per pipeline stage.");
+	const stageName = stageNames[0];
+	if (stageName === "$merge" || stageName === "$out") throw new Error(`ACL-protected aggregates cannot use ${stageName}. Use models.getUnsafe(...) after explicit authorization.`);
+	if (!allowedAggregateStages.has(stageName)) throw new Error(`ACL-protected aggregates cannot use unreviewed stage ${stageName}. Use models.getUnsafe(...) explicitly.`);
+};
+var secureTargetPipeline = (pipeline, targetModel, ability) => {
+	secureAggregateStages(pipeline, targetModel, ability);
+	if (!hasRegisteredPolicy(targetModel.modelName)) return;
+	if (!ability) throw new Error(`ACL-protected aggregate target "${targetModel.modelName}" requires .acl(ability).`);
+	injectAggregateMatch(pipeline, castMongoQuery(targetModel, accessibleBy(ability, "read").ofType(targetModel.modelName)));
+};
+var secureAggregateStages = (pipeline, sourceModel, ability) => {
+	for (const stage of pipeline) {
+		if (!isRecord(stage)) throw new Error("ACL-protected aggregates require object pipeline stages.");
+		if (containsSearchMetadataReference(stage)) throw new Error("ACL-protected aggregates cannot expose $$SEARCH_META because it includes unauthorized search matches.");
+		assertAllowedAggregateStage(stage);
+		if (isRecord(stage.$lookup)) {
+			const lookup = stage.$lookup;
+			const nestedPipeline = Array.isArray(lookup.pipeline) ? lookup.pipeline : [];
+			if (typeof lookup.from === "string") {
+				const targetModel = resolveAggregateModel(sourceModel, lookup.from);
+				lookup.pipeline = nestedPipeline;
+				secureTargetPipeline(nestedPipeline, targetModel, ability);
+			} else if (lookup.from === void 0 && Array.isArray(lookup.pipeline)) secureAggregateStages(nestedPipeline, sourceModel, ability);
+			else throw new Error("ACL-protected $lookup requires a registered collection name in `from`.");
+		}
+		if (typeof stage.$unionWith === "string") {
+			const targetModel = resolveAggregateModel(sourceModel, stage.$unionWith);
+			const nestedPipeline = [];
+			stage.$unionWith = {
+				coll: stage.$unionWith,
+				pipeline: nestedPipeline
+			};
+			secureTargetPipeline(nestedPipeline, targetModel, ability);
+		} else if (isRecord(stage.$unionWith)) {
+			const unionWith = stage.$unionWith;
+			const nestedPipeline = Array.isArray(unionWith.pipeline) ? unionWith.pipeline : [];
+			if (typeof unionWith.coll === "string") {
+				const targetModel = resolveAggregateModel(sourceModel, unionWith.coll);
+				unionWith.pipeline = nestedPipeline;
+				secureTargetPipeline(nestedPipeline, targetModel, ability);
+			} else if (unionWith.coll === void 0 && Array.isArray(unionWith.pipeline)) secureAggregateStages(nestedPipeline, sourceModel, ability);
+			else throw new Error("ACL-protected $unionWith requires a registered collection name in `coll`.");
+		}
+		if (isRecord(stage.$graphLookup)) {
+			const graphLookup = stage.$graphLookup;
+			const collectionName = graphLookup.from;
+			if (typeof collectionName !== "string") throw new Error("ACL-protected $graphLookup requires a registered collection name in `from`.");
+			const targetModel = resolveAggregateModel(sourceModel, collectionName);
+			if (hasRegisteredPolicy(targetModel.modelName)) {
+				if (!ability) throw new Error(`ACL-protected aggregate target "${targetModel.modelName}" requires .acl(ability).`);
+				const targetAccessQuery = castMongoQuery(targetModel, accessibleBy(ability, "read").ofType(targetModel.modelName));
+				graphLookup.restrictSearchWithMatch = mergeMongoQuery(graphLookup.restrictSearchWithMatch, targetAccessQuery);
+			}
+		}
+		if (isRecord(stage.$facet)) for (const nestedPipeline of Object.values(stage.$facet)) {
+			if (!Array.isArray(nestedPipeline)) throw new Error("ACL-protected $facet entries must be pipelines.");
+			secureAggregateStages(nestedPipeline, sourceModel, ability);
+		}
+	}
+};
+var secureAggregatePipeline = (pipeline, model, ability, action) => {
+	secureAggregateStages(pipeline, model, ability);
+	if (!hasRegisteredPolicy(model.modelName)) return;
+	if (!ability) throw new Error(`ACL-protected model "${model.modelName}" requires .acl(ability).`);
+	injectAggregateMatch(pipeline, castMongoQuery(model, accessibleBy(ability, action).ofType(model.modelName)));
+};
+//#endregion
+//#region src/acl/mongooseAclDriverContext.ts
+var contextStorage = new AsyncLocalStorage();
+var collectionContexts = /* @__PURE__ */ new WeakMap();
+var rawConnections = /* @__PURE__ */ new WeakMap();
+var unsafeMongooseAclDriverContext = Object.freeze({ mode: "unsafe" });
+var unboundMongooseAclDriverContext = Object.freeze({ mode: "unbound" });
+var bindMongooseAclDriverContext = (value, context) => {
+	collectionContexts.set(value, context);
+};
+var getMongooseAclDriverContext = (value) => {
+	return (value ? collectionContexts.get(value) : void 0) ?? contextStorage.getStore();
+};
+var bindMongooseAclRawConnection = (scopedConnection, rawConnection) => {
+	rawConnections.set(scopedConnection, rawConnection);
+};
+var getMongooseAclRawConnection = (connection) => rawConnections.get(connection) ?? connection;
+var runWithMongooseAclDriverContext = (context, callback) => contextStorage.run(context, callback);
+//#endregion
+//#region src/acl/mongooseAclDriver.ts
+var nativeDriver = mongoose$1.driver.get();
+var NativeCollection = nativeDriver.Collection;
+var rawCollections = /* @__PURE__ */ new WeakMap();
+var rawCollectionProxies = /* @__PURE__ */ new WeakMap();
+var blockedNativeCollectionProperties = /* @__PURE__ */ new Set([
+	"client",
+	"db",
+	"s"
+]);
+var blockedCursorProperties = /* @__PURE__ */ new Set([
+	"aggregateOptions",
+	"client",
+	"cursorClient",
+	"cursorFilter",
+	"cursorOptions",
+	"cursorSession",
+	"selectedServer",
+	"server",
+	"session"
+]);
+var aggregateCursorMutationMethods = /* @__PURE__ */ new Set([
+	"addStage",
+	"geoNear",
+	"group",
+	"limit",
+	"lookup",
+	"match",
+	"out",
+	"project",
+	"redact",
+	"skip",
+	"sort",
+	"unwind"
+]);
+var dataMethods = /* @__PURE__ */ new Set([
+	"aggregate",
+	"bulkWrite",
+	"count",
+	"countDocuments",
+	"deleteMany",
+	"deleteOne",
+	"distinct",
+	"estimatedDocumentCount",
+	"find",
+	"findOne",
+	"findOneAndDelete",
+	"findOneAndReplace",
+	"findOneAndUpdate",
+	"insertMany",
+	"insertOne",
+	"replaceOne",
+	"updateMany",
+	"updateOne"
+]);
+var readFilterArgumentByMethod = {
+	count: 0,
+	countDocuments: 0,
+	distinct: 1,
+	find: 0,
+	findOne: 0
+};
+var writeFilterActionByMethod = {
+	deleteMany: "delete",
+	deleteOne: "delete",
+	findOneAndDelete: "delete",
+	findOneAndReplace: "update",
+	findOneAndUpdate: "update",
+	replaceOne: "update",
+	updateMany: "update",
+	updateOne: "update"
+};
+var getCollectionName = (collection) => {
+	const value = collection.collectionName ?? collection.name;
+	return typeof value === "string" ? value : "";
+};
+var getModelCollectionName$1 = (model) => {
+	const collection = model.collection;
+	if (typeof collection.collectionName === "string") return collection.collectionName;
+	if (typeof collection.name === "string") return collection.name;
+	return null;
+};
+var getCollectionModels = (collection) => {
+	const collectionName = getCollectionName(collection);
+	const candidates = /* @__PURE__ */ new Map();
+	for (const model of [...Object.values(mongoose$1.models), ...Object.values(collection.conn.models ?? {})]) {
+		const typedModel = model;
+		if (getModelCollectionName$1(typedModel) === collectionName) candidates.set(typedModel.modelName, typedModel);
+	}
+	return candidates;
+};
+var getCollectionModelName = (collection) => {
+	if (typeof collection.modelName === "string" && collection.modelName) return collection.modelName;
+	const candidates = getCollectionModels(collection);
+	return candidates.size === 1 ? [...candidates.keys()][0] : null;
+};
+var getProtectedCollectionModelNames = (collection) => [...getCollectionModels(collection).keys()].filter(hasRegisteredPolicy);
+var hasSecuredCollectionBoundary = (collection) => {
+	const context = getMongooseAclDriverContext(collection);
+	if (context) return context.mode !== "unsafe";
+	if (typeof collection.modelName === "string" && collection.modelName) {
+		if (hasRegisteredPolicy(collection.modelName)) return true;
+	}
+	return [...getCollectionModels(collection).keys()].some(hasRegisteredPolicy);
+};
+var getCollectionModel = (collection, modelName) => {
+	const model = collection.conn.models?.[modelName] ?? mongoose$1.models[modelName];
+	if (!model) throw new Error(`ACL driver could not resolve Mongoose model "${modelName}".`);
+	return model;
+};
+var getAccessQuery = (ability, action, model) => castMongoQuery(model, accessibleBy(ability, action).ofType(model.modelName));
+var assertCanCreate = (ability, modelName, value) => {
+	const rawValue = value instanceof mongoose$1.Document ? value.toObject() : value;
+	const document = isRecord(rawValue) ? rawValue : {};
+	ForbiddenError.from(ability).throwUnlessCan("create", subject(modelName, document));
+};
+var materializeBsonValue = (value, seen) => {
+	if (!value || typeof value !== "object") return value;
+	if (seen.has(value)) return seen.get(value);
+	const toBSON = value.toBSON;
+	if (typeof toBSON === "function") {
+		const placeholder = Object.create(null);
+		seen.set(value, placeholder);
+		const materialized = Reflect.apply(toBSON, value, []);
+		if (materialized !== value) {
+			const result = materializeBsonValue(materialized, seen);
+			seen.set(value, result);
+			return result;
+		}
+		for (const [key, entry] of Object.entries(value)) {
+			if (key === "toBSON" && typeof entry === "function") continue;
+			placeholder[key] = materializeBsonValue(entry, seen);
+		}
+		return placeholder;
+	}
+	if (value instanceof Date || Buffer.isBuffer(value)) return cloneMongoValue(value);
+	if (value instanceof RegExp || ArrayBuffer.isView(value) || isRecord(value) && typeof value._bsontype === "string") return value;
+	if (Array.isArray(value)) {
+		const copy = [];
+		seen.set(value, copy);
+		for (const entry of value) copy.push(materializeBsonValue(entry, seen));
+		return copy;
+	}
+	if (value instanceof Map) {
+		const copy = /* @__PURE__ */ new Map();
+		seen.set(value, copy);
+		for (const [key, entry] of value) copy.set(key, materializeBsonValue(entry, seen));
+		return copy;
+	}
+	const copy = Object.create(null);
+	seen.set(value, copy);
+	for (const [key, entry] of Object.entries(value)) copy[key] = materializeBsonValue(entry, seen);
+	return copy;
+};
+var materializeInsertDocument = (value) => materializeBsonValue(value, /* @__PURE__ */ new WeakMap());
+var safeExplainVerbosities = /* @__PURE__ */ new Set(["queryPlanner", "queryPlannerExtended"]);
+var isSafeExplainVerbosity = (value) => {
+	if (value === false) return true;
+	if (typeof value === "string") return safeExplainVerbosities.has(value);
+	return isRecord(value) && isSafeExplainVerbosity(value.verbosity);
+};
+var assertSafeExplainVerbosity = (value) => {
+	if (!isSafeExplainVerbosity(value)) throw new Error("ACL-protected cursors cannot expose execution statistics. Use queryPlanner verbosity or models.getUnsafe(...) explicitly.");
+};
+var assertSafeExplainOptions = (options) => {
+	if (isRecord(options) && Object.hasOwn(options, "explain") && options.explain != null) assertSafeExplainVerbosity(options.explain);
+};
+var assertNoUpsert = (methodName, options) => {
+	if (isRecord(options) && options.upsert === true) throw new Error(`ACL-protected ${methodName}() cannot use upsert. Use models.getUnsafe(...) after explicit create and update authorization.`);
+};
+var secureBulkWriteOperations = (ability, model, value) => {
+	if (!Array.isArray(value)) throw new TypeError("ACL-protected bulkWrite() expects an array of operations.");
+	return value.map((operation) => {
+		if (!isRecord(operation)) throw new TypeError("ACL-protected bulkWrite() received an invalid operation.");
+		const operationActions = [
+			{
+				key: "updateOne",
+				action: "update"
+			},
+			{
+				key: "updateMany",
+				action: "update"
+			},
+			{
+				key: "replaceOne",
+				action: "update"
+			},
+			{
+				key: "deleteOne",
+				action: "delete"
+			},
+			{
+				key: "deleteMany",
+				action: "delete"
+			}
+		];
+		const supportedKeys = ["insertOne", ...operationActions.map(({ key }) => key)].filter((key) => Object.hasOwn(operation, key));
+		if (supportedKeys.length !== 1 || Object.keys(operation).length !== 1) throw new Error("ACL-protected bulkWrite() requires exactly one supported operator per operation.");
+		if (supportedKeys[0] === "insertOne" && isRecord(operation.insertOne)) {
+			const document = materializeInsertDocument(operation.insertOne.document);
+			assertCanCreate(ability, model.modelName, document);
+			return {
+				...cloneMongoValue(operation),
+				insertOne: {
+					...cloneMongoValue(operation.insertOne),
+					document
+				}
+			};
+		}
+		for (const { key, action } of operationActions) {
+			const details = operation[key];
+			if (!isRecord(details)) continue;
+			assertNoUpsert(`bulkWrite ${key}`, details);
+			return {
+				...cloneMongoValue(operation),
+				[key]: {
+					...cloneMongoValue(details),
+					filter: mergeMongoQuery(details.filter, getAccessQuery(ability, action, model))
+				}
+			};
+		}
+		throw new Error("ACL-protected bulkWrite() received an unsupported operation.");
+	});
+};
+var secureCollectionArguments = (collection, ability, modelName, methodName, input) => {
+	const args = input.map((value) => cloneMongoValue(value));
+	const model = getCollectionModel(collection, modelName);
+	if (methodName === "find" || methodName === "findOne" || methodName === "aggregate") assertSafeExplainOptions(args[1]);
+	const readFilterIndex = readFilterArgumentByMethod[methodName];
+	if (readFilterIndex !== void 0) {
+		args[readFilterIndex] = mergeMongoQuery(args[readFilterIndex], getAccessQuery(ability, "read", model));
+		return args;
+	}
+	const writeAction = writeFilterActionByMethod[methodName];
+	if (writeAction) {
+		if (writeAction === "update") assertNoUpsert(methodName, args[2]);
+		args[0] = mergeMongoQuery(args[0], getAccessQuery(ability, writeAction, model));
+		return args;
+	}
+	if (methodName === "insertOne") {
+		args[0] = materializeInsertDocument(input[0]);
+		assertCanCreate(ability, modelName, args[0]);
+		return args;
+	}
+	if (methodName === "insertMany") {
+		if (!Array.isArray(input[0])) throw new TypeError("ACL-protected insertMany() expects an array of documents.");
+		const documents = input[0].map((document) => materializeInsertDocument(document));
+		for (const document of documents) assertCanCreate(ability, modelName, document);
+		args[0] = documents;
+		return args;
+	}
+	if (methodName === "bulkWrite") {
+		args[0] = secureBulkWriteOperations(ability, model, input[0]);
+		return args;
+	}
+	if (methodName === "aggregate") {
+		if (!Array.isArray(args[0])) throw new TypeError("ACL-protected aggregate() expects a pipeline array.");
+		const pipeline = args[0];
+		secureAggregatePipeline(pipeline, model, ability, "read");
+		args[0] = pipeline;
+		return args;
+	}
+	if (methodName === "estimatedDocumentCount") throw new Error("ACL-protected estimatedDocumentCount() cannot be filtered. Use countDocuments() or models.getUnsafe(...).");
+	throw new Error(`ACL-protected collection method ${methodName}() is not supported. Use models.getUnsafe(...) explicitly.`);
+};
+var wrapFindCursor = (cursor) => {
+	const proxy = new Proxy(cursor, {
+		get(target, prop) {
+			if (blockedCursorProperties.has(prop)) throw new Error(`ACL-protected cursor property .${String(prop)} is blocked.`);
+			const value = Reflect.get(target, prop, target);
+			if (prop === "filter") return () => {
+				throw new Error("ACL-protected cursors cannot replace their filter.");
+			};
+			if (prop === "addQueryModifier" && typeof value === "function") return (...args) => {
+				if (args[0] === "$query") throw new Error("ACL-protected cursors cannot replace their filter.");
+				if (args[0] === "$explain") assertSafeExplainVerbosity(args[1]);
+				const result = Reflect.apply(value, target, args);
+				return result === target ? proxy : result;
+			};
+			if (prop === "explain" && typeof value === "function") return (...args) => {
+				assertSafeExplainVerbosity(args[0]);
+				return Reflect.apply(value, target, args);
+			};
+			if (typeof value !== "function") return value;
+			return (...args) => {
+				const result = Reflect.apply(value, target, args);
+				if (prop === "stream" && result && typeof result === "object") return wrapCursorStream(result);
+				if (prop === "clone" && result && typeof result === "object") return wrapFindCursor(result);
+				return result === target ? proxy : result;
+			};
+		},
+		set() {
+			throw new Error("ACL-protected cursors cannot be mutated directly.");
+		}
+	});
+	return proxy;
+};
+var wrapCursorStream = (stream) => {
+	const proxy = new Proxy(stream, {
+		get(target, prop) {
+			if (prop === "_cursor") throw new Error("ACL-protected cursor streams do not expose their native cursor.");
+			const value = Reflect.get(target, prop, target);
+			if (typeof value !== "function") return value;
+			return (...args) => {
+				const result = Reflect.apply(value, target, args);
+				return result === target ? proxy : result;
+			};
+		},
+		set(target, prop, value) {
+			if (prop === "_cursor") throw new Error("ACL-protected cursor streams cannot replace their native cursor.");
+			return Reflect.set(target, prop, value, target);
+		}
+	});
+	return proxy;
+};
+var wrapAggregateCursor = (cursor) => {
+	const proxy = new Proxy(cursor, {
+		get(target, prop) {
+			if (blockedCursorProperties.has(prop)) throw new Error(`ACL-protected aggregation cursor property .${String(prop)} is blocked.`);
+			if (prop === "pipeline") return cloneMongoValue(Reflect.get(target, prop, target));
+			const value = Reflect.get(target, prop, target);
+			if (aggregateCursorMutationMethods.has(prop)) return () => {
+				throw new Error("ACL-protected aggregation cursors cannot mutate their pipeline after validation.");
+			};
+			if (prop === "explain" && typeof value === "function") return (...args) => {
+				assertSafeExplainVerbosity(args[0]);
+				return Reflect.apply(value, target, args);
+			};
+			if (typeof value !== "function") return value;
+			return (...args) => {
+				const result = Reflect.apply(value, target, args);
+				if (prop === "stream" && result && typeof result === "object") return wrapCursorStream(result);
+				if (prop === "clone" && result && typeof result === "object") return wrapAggregateCursor(result);
+				return result === target ? proxy : result;
+			};
+		},
+		set() {
+			throw new Error("ACL-protected aggregation cursors cannot be mutated directly.");
+		}
+	});
+	return proxy;
+};
+var wrapCursorResult = (methodName, result) => {
+	if (result && typeof result === "object" && "then" in result && typeof result.then === "function") return Promise.resolve(result).then((resolved) => wrapCursorResult(methodName, resolved));
+	if (!result || typeof result !== "object") return result;
+	if (methodName === "find") return wrapFindCursor(result);
+	if (methodName === "aggregate") return wrapAggregateCursor(result);
+	return result;
+};
+var invokeSafeUnprotectedCollectionMethod = (collection, rawCollection, modelName, context, methodName, method, input) => {
+	if (!dataMethods.has(methodName)) throw new Error(`Safe collection method ${methodName}() is not supported. Use models.getUnsafe(...) explicitly.`);
+	const args = input.map((value) => cloneMongoValue(value));
+	if (methodName === "aggregate") {
+		if (!Array.isArray(args[0])) throw new TypeError("Safe aggregate() expects a pipeline array.");
+		secureAggregatePipeline(args[0], getCollectionModel(collection, modelName), context.mode === "ability" ? context.ability : void 0, "read");
+	}
+	return wrapCursorResult(methodName, Reflect.apply(method, rawCollection, args));
+};
+var invokeNativeCollectionMethod = (collection, rawCollection, methodName, method, input) => {
+	const context = getMongooseAclDriverContext(collection);
+	const modelName = getCollectionModelName(collection);
+	if (context?.mode === "unsafe") return Reflect.apply(method, rawCollection, input);
+	if (modelName && !hasRegisteredPolicy(modelName)) {
+		if (getProtectedCollectionModelNames(collection).length > 0) throw new Error(`Model "${modelName}" maps to ACL-protected collection "${getCollectionName(collection)}" without its own policy.`);
+		if (!context) return Reflect.apply(method, rawCollection, input);
+		return invokeSafeUnprotectedCollectionMethod(collection, rawCollection, modelName, context, methodName, method, input);
+	}
+	if (!modelName) {
+		const collectionModels = getCollectionModels(collection);
+		const protectedModelNames = [...collectionModels.keys()].filter(hasRegisteredPolicy);
+		if (collectionModels.size > 0 && protectedModelNames.length === 0) {
+			if (!context) return Reflect.apply(method, rawCollection, input);
+			return invokeSafeUnprotectedCollectionMethod(collection, rawCollection, [...collectionModels.keys()][0], context, methodName, method, input);
+		}
+		if (protectedModelNames.length > 0) throw new Error(`ACL driver cannot choose a policy for collection "${getCollectionName(collection)}" (${protectedModelNames.join(", ")}). Use models.get(...).acl(ability).`);
+		throw new Error(`ACL driver cannot authorize unregistered collection "${getCollectionName(collection)}". Use models.getUnsafe(...) explicitly.`);
+	}
+	if (context?.mode !== "ability") {
+		if (context?.mode === "unbound") throw new Error(`Model "${modelName}" is ACL-protected. Call .acl(ability) before executing the operation.`);
+		throw new Error(`Model "${modelName}" is ACL-protected. Use models.get(...).acl(ability) or models.getUnsafe(...) explicitly.`);
+	}
+	if (!dataMethods.has(methodName)) throw new Error(`ACL-protected collection method ${methodName}() is not filterable. Use models.getUnsafe(...) explicitly.`);
+	const args = secureCollectionArguments(collection, context.ability, modelName, methodName, input);
+	return wrapCursorResult(methodName, Reflect.apply(method, rawCollection, args));
+};
+var getRawCollectionProxy = (collection, rawCollection) => {
+	const cached = rawCollectionProxies.get(collection);
+	if (cached?.raw === rawCollection) return cached.proxy;
+	const proxy = new Proxy(rawCollection, {
+		get(target, prop) {
+			if (blockedNativeCollectionProperties.has(prop) && hasSecuredCollectionBoundary(collection)) throw new Error(`ACL-protected native collection property .${String(prop)} is blocked. Use models.getUnsafe(...) explicitly.`);
+			const value = Reflect.get(target, prop, target);
+			if (typeof value !== "function") return value;
+			return (...args) => invokeNativeCollectionMethod(collection, target, String(prop), value, args);
+		},
+		set(target, prop, value) {
+			if (hasSecuredCollectionBoundary(collection)) throw new Error(`ACL-protected native collection property .${String(prop)} cannot be changed. Use models.getUnsafe(...) explicitly.`);
+			return Reflect.set(target, prop, value, target);
+		}
+	});
+	rawCollectionProxies.set(collection, {
+		raw: rawCollection,
+		proxy
+	});
+	return proxy;
+};
+var installRawCollectionAccessor = (collection) => {
+	const initialRawCollection = collection.collection;
+	Object.defineProperty(collection, "collection", {
+		configurable: true,
+		enumerable: true,
+		get() {
+			const rawCollection = rawCollections.get(collection);
+			return rawCollection ? getRawCollectionProxy(collection, rawCollection) : rawCollection;
+		},
+		set(value) {
+			rawCollections.set(collection, value && typeof value === "object" ? value : null);
+			rawCollectionProxies.delete(collection);
+		}
+	});
+	collection.collection = initialRawCollection;
+};
+var AclMongooseCollection = class extends NativeCollection {
+	constructor(name, connection, options = {}) {
+		super(name, connection, options);
+		installRawCollectionAccessor(this);
+	}
+};
+var ACL_DRIVER_GLOBAL_KEY = Symbol.for("@rpcbase/db/acl/mongooseDriverInstalled");
+var installMongooseAclDriver = () => {
+	const globalState = globalThis;
+	const installedInstances = globalState[ACL_DRIVER_GLOBAL_KEY] instanceof WeakSet ? globalState[ACL_DRIVER_GLOBAL_KEY] : /* @__PURE__ */ new WeakSet();
+	if (installedInstances.has(mongoose$1)) return;
+	mongoose$1.setDriver({
+		...nativeDriver,
+		Collection: AclMongooseCollection
+	});
+	installedInstances.add(mongoose$1);
+	globalState[ACL_DRIVER_GLOBAL_KEY] = installedInstances;
+};
+var runWithUnsafeMongooseAclDriver = (callback) => runWithMongooseAclDriverContext(unsafeMongooseAclDriverContext, callback);
+//#endregion
 //#region src/ensureMongooseConnection.ts
+installMongooseAclDriver();
 var connections = /* @__PURE__ */ new Map();
 var rootConnection = null;
 var CONNECTION_MAX_LISTENERS = 50;
@@ -1640,9 +2278,10 @@ var getQuerySession = (query) => {
 	return session;
 };
 var getRtsModels = (db) => {
+	const rawDb = getMongooseAclRawConnection(db);
 	return {
-		RtsCounter: db.models.RBRtsCounter ?? db.model("RBRtsCounter", RBRtsCounterSchema),
-		RtsChange: db.models.RBRtsChange ?? db.model("RBRtsChange", RBRtsChangeSchema)
+		RtsCounter: rawDb.models.RBRtsCounter ?? rawDb.model("RBRtsCounter", RBRtsCounterSchema),
+		RtsChange: rawDb.models.RBRtsChange ?? rawDb.model("RBRtsChange", RBRtsChangeSchema)
 	};
 };
 var allocateSeqRange = async (db, count, session) => {
@@ -1776,157 +2415,6 @@ var rtsChangeLogPlugin = (schema) => {
 	});
 };
 //#endregion
-//#region src/acl/mongooseAclPlugin.ts
-var isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
-var mergeMongoQuery = (left, right) => {
-	const leftQuery = isRecord(left) ? left : {};
-	if (Object.keys(leftQuery).length === 0) return right;
-	if (Object.keys(right).length === 0) return leftQuery;
-	return { $and: [leftQuery, right] };
-};
-var getQueryOptions = (query) => {
-	if (!query || typeof query !== "object") return void 0;
-	if (!("getOptions" in query) || typeof query.getOptions !== "function") return void 0;
-	return query.getOptions();
-};
-var getStoredAclFromQuery = (query) => {
-	const raw = getQueryOptions(query)?.rbAcl;
-	if (!isRecord(raw)) return null;
-	if (!("ability" in raw)) return null;
-	return raw;
-};
-var getStoredAclFromAggregate = (aggregate) => {
-	if (!aggregate || typeof aggregate !== "object") return null;
-	const raw = aggregate.options;
-	if (!isRecord(raw)) return null;
-	const acl = raw.rbAcl;
-	if (!isRecord(acl)) return null;
-	if (!("ability" in acl)) return null;
-	return acl;
-};
-var addQueryAclFilter = (query, action) => {
-	const storedAcl = getStoredAclFromQuery(query);
-	if (!storedAcl) return;
-	const ability = storedAcl.ability;
-	const resolvedAction = storedAcl.action ?? action;
-	const modelName = query.model.modelName;
-	const accessQuery = accessibleBy(ability, resolvedAction).ofType(modelName);
-	query.and([accessQuery]);
-};
-var injectAggregateMatch = (pipeline, match) => {
-	if (pipeline.length === 0) {
-		pipeline.unshift({ $match: match });
-		return;
-	}
-	const first = pipeline[0];
-	if (!isRecord(first)) {
-		pipeline.unshift({ $match: match });
-		return;
-	}
-	if ("$geoNear" in first) {
-		const geoNear = first.$geoNear;
-		if (isRecord(geoNear)) {
-			geoNear.query = mergeMongoQuery(geoNear.query, match);
-			return;
-		}
-	}
-	if ("$search" in first || "$vectorSearch" in first || "$searchMeta" in first) {
-		pipeline.splice(1, 0, { $match: match });
-		return;
-	}
-	pipeline.unshift({ $match: match });
-};
-var addAggregateAclFilter = (aggregate, action) => {
-	const storedAcl = getStoredAclFromAggregate(aggregate);
-	if (!storedAcl) return;
-	const ability = storedAcl.ability;
-	const resolvedAction = storedAcl.action ?? action;
-	const modelName = aggregate.model().modelName;
-	const accessQuery = accessibleBy(ability, resolvedAction).ofType(modelName);
-	injectAggregateMatch(aggregate.pipeline(), accessQuery);
-};
-var patchAggregateAcl = () => {
-	const globalKey = Symbol.for("@rpcbase/db/acl/mongooseAggregateAclPatched");
-	const globalState = globalThis;
-	if (globalState[globalKey]) return;
-	globalState[globalKey] = true;
-	const AggregatePrototype = mongoose$1.Aggregate.prototype;
-	if (typeof AggregatePrototype.acl === "function") return;
-	AggregatePrototype.acl = function(ability, action = "read") {
-		this.option({ rbAcl: {
-			ability,
-			action
-		} });
-		return this;
-	};
-};
-var createModelAclProxy = (model, ability) => {
-	return new Proxy(model, { get(target, prop, receiver) {
-		if (prop === "acl") return () => {
-			throw new Error(`Model "${target.modelName}" is already ACL-scoped. Do not call .acl(...) again.`);
-		};
-		const value = Reflect.get(target, prop, receiver);
-		if (typeof value !== "function") return value;
-		return (...args) => {
-			const result = Reflect.apply(value, target, args);
-			if (result && typeof result === "object" && "acl" in result && typeof result.acl === "function") return result.acl(ability);
-			return result;
-		};
-	} });
-};
-var mongooseAclPlugin = (schema) => {
-	patchAggregateAcl();
-	schema.query.acl = function(ability, action) {
-		this.setOptions({ rbAcl: {
-			ability,
-			action
-		} });
-		return this;
-	};
-	schema.statics.acl = function(ability) {
-		return createModelAclProxy(this, ability);
-	};
-	schema.pre("aggregate", function() {
-		addAggregateAclFilter(this, "read");
-	});
-	schema.pre("countDocuments", function() {
-		addQueryAclFilter(this, "read");
-	});
-	schema.pre("deleteMany", function() {
-		addQueryAclFilter(this, "delete");
-	});
-	schema.pre("deleteOne", function() {
-		addQueryAclFilter(this, "delete");
-	});
-	schema.pre("distinct", function() {
-		addQueryAclFilter(this, "read");
-	});
-	schema.pre("find", function() {
-		addQueryAclFilter(this, "read");
-	});
-	schema.pre("findOne", function() {
-		addQueryAclFilter(this, "read");
-	});
-	schema.pre("findOneAndDelete", function() {
-		addQueryAclFilter(this, "delete");
-	});
-	schema.pre("findOneAndReplace", function() {
-		addQueryAclFilter(this, "update");
-	});
-	schema.pre("findOneAndUpdate", function() {
-		addQueryAclFilter(this, "update");
-	});
-	schema.pre("replaceOne", function() {
-		addQueryAclFilter(this, "update");
-	});
-	schema.pre("updateMany", function() {
-		addQueryAclFilter(this, "update");
-	});
-	schema.pre("updateOne", function() {
-		addQueryAclFilter(this, "update");
-	});
-};
-//#endregion
 //#region src/registerModels.ts
 var cachedModels = null;
 var DEFAULT_GLOBAL_RB_MODEL_NAMES_SET = /* @__PURE__ */ new Set([
@@ -1949,7 +2437,6 @@ var getFrameworkSchemaForModelName = (modelName) => {
 };
 var applyTenantPlugins = (schema) => {
 	schema.plugin(accessibleRecordsPlugin);
-	schema.plugin(mongooseAclPlugin);
 	schema.plugin(mongoPaginationPlugin);
 	schema.plugin(rtsChangeLogPlugin);
 };
@@ -1965,6 +2452,7 @@ var buildSchemasFromModules = (modules) => Object.entries(modules).filter(([key]
 	};
 });
 var registerModels = ({ tenant, global }, options = {}) => {
+	installMongooseAclDriver();
 	registerPoliciesFromModules(models_exports);
 	registerPoliciesFromModules(tenant);
 	const tenantSchemas = {};
@@ -1999,7 +2487,7 @@ var registerModels = ({ tenant, global }, options = {}) => {
 		...globalSchemas,
 		...tenantSchemas
 	};
-	for (const [modelName, schema] of Object.entries(allSchemas)) if (!mongoose$1.models[modelName]) mongoose$1.model(modelName, schema);
+	for (const [modelName, schema] of Object.entries(allSchemas)) if (!mongoose$1.models[modelName]) runWithUnsafeMongooseAclDriver(() => mongoose$1.model(modelName, schema));
 	cachedModels = {
 		tenant: {
 			...cachedModels?.tenant ?? {},
@@ -2016,13 +2504,388 @@ var getRegisteredModels = (scope) => {
 	return cachedModels[scope];
 };
 //#endregion
+//#region src/acl/mongooseAclModel.ts
+var scopedModelsByAbility = /* @__PURE__ */ new WeakMap();
+var unboundModels = /* @__PURE__ */ new WeakMap();
+var unsafeModels = /* @__PURE__ */ new WeakMap();
+var collectionTargets = /* @__PURE__ */ new WeakMap();
+var blockedModelMethods = /* @__PURE__ */ new Set([
+	"$__updateConnection",
+	"__subclass",
+	"clientEncryption",
+	"cleanIndexes",
+	"compile",
+	"createCollection",
+	"createIndexes",
+	"createSearchIndex",
+	"createSearchIndexes",
+	"diffIndexes",
+	"dropSearchIndex",
+	"ensureIndexes",
+	"init",
+	"listIndexes",
+	"listSearchIndexes",
+	"recompileSchema",
+	"startSession",
+	"syncIndexes",
+	"updateSearchIndex",
+	"useConnection",
+	"watch"
+]);
+var blockedCollectionProperties = /* @__PURE__ */ new Set([
+	"_getCollection",
+	"addQueue",
+	"doQueue",
+	"emitter",
+	"onClose",
+	"onOpen",
+	"queue",
+	"removeQueue"
+]);
+var blockedConnectionMethods = /* @__PURE__ */ new Set([
+	"aggregate",
+	"bulkWrite",
+	"close",
+	"createClient",
+	"createCollection",
+	"createCollections",
+	"deleteModel",
+	"destroy",
+	"doClose",
+	"dropCollection",
+	"dropDatabase",
+	"listCollections",
+	"listDatabases",
+	"onClose",
+	"onOpen",
+	"openUri",
+	"plugin",
+	"set",
+	"setClient",
+	"startSession",
+	"syncIndexes",
+	"transaction",
+	"useDb",
+	"watch",
+	"withSession"
+]);
+var blockedConnectionProperties = /* @__PURE__ */ new Set([
+	"$initialConnection",
+	"_parent",
+	"client",
+	"otherDbs",
+	"relatedDbs"
+]);
+var blockedMongooseMethods = /* @__PURE__ */ new Set([
+	"connect",
+	"createConnection",
+	"deleteModel",
+	"disconnect",
+	"model",
+	"plugin",
+	"set",
+	"setDriver",
+	"startSession",
+	"syncIndexes"
+]);
+var blockedMongooseProperties = /* @__PURE__ */ new Set([
+	"connection",
+	"connections",
+	"models"
+]);
+var allowedDbProperties = /* @__PURE__ */ new Set([
+	"databaseName",
+	"namespace",
+	"readConcern",
+	"readPreference",
+	"writeConcern"
+]);
+var getModelCollectionName = (model) => {
+	const collection = model.collection;
+	const value = collection.collectionName ?? collection.name;
+	return typeof value === "string" ? value : "";
+};
+var resolveModelNameForCollection = (connection, collectionName) => {
+	const candidates = /* @__PURE__ */ new Set();
+	for (const model of [...Object.values(connection.models ?? {}), ...Object.values(mongoose$1.models)]) {
+		const typedModel = model;
+		if (getModelCollectionName(typedModel) === collectionName) candidates.add(typedModel.modelName);
+	}
+	return candidates.size === 1 ? [...candidates][0] : void 0;
+};
+var detachMongooseSubclassRetention = (rawModel, scopedModel) => {
+	const symbol = Object.getOwnPropertySymbols(rawModel).find((entry) => entry.description === "mongoose#Model#subclassed");
+	if (!symbol) return;
+	const subclasses = rawModel[symbol];
+	if (!Array.isArray(subclasses)) return;
+	const index = subclasses.lastIndexOf(scopedModel);
+	if (index >= 0) subclasses.splice(index, 1);
+};
+var getCachedModel = (model, context) => {
+	if (context.mode === "unsafe") return unsafeModels.get(model);
+	if (context.mode === "unbound") return unboundModels.get(model);
+	return scopedModelsByAbility.get(context.ability)?.get(model);
+};
+var cacheModel = (rawModel, scopedModel, context) => {
+	if (context.mode === "unsafe") {
+		unsafeModels.set(rawModel, scopedModel);
+		return;
+	}
+	if (context.mode === "unbound") {
+		unboundModels.set(rawModel, scopedModel);
+		return;
+	}
+	const models = scopedModelsByAbility.get(context.ability) ?? /* @__PURE__ */ new WeakMap();
+	models.set(rawModel, scopedModel);
+	scopedModelsByAbility.set(context.ability, models);
+};
+var lockModelCapability = (target, property, value) => {
+	const descriptor = Object.getOwnPropertyDescriptor(target, property);
+	Object.defineProperty(target, property, {
+		configurable: false,
+		enumerable: descriptor?.enumerable ?? true,
+		get: () => value,
+		set: () => {
+			throw new Error(`ACL-protected model property .${String(property)} cannot be changed. Use models.getUnsafe(...) explicitly.`);
+		}
+	});
+};
+var createAclModelWithContext = (model, context) => {
+	const cached = getCachedModel(model, context);
+	if (cached) return cached;
+	const rawConnection = model.db;
+	const primaryCollectionName = getModelCollectionName(model);
+	const collections = /* @__PURE__ */ new Map();
+	let mongooseProxy;
+	let collectionsProxy;
+	let modelsProxy;
+	let dbProxy;
+	const getMongooseProxy = () => {
+		const rawMongoose = rawConnection.base;
+		if (context.mode === "unsafe") return rawMongoose;
+		if (mongooseProxy) return mongooseProxy;
+		mongooseProxy = new Proxy(rawMongoose, {
+			get(target, prop) {
+				if (prop === "default" || prop === "mongoose") return mongooseProxy;
+				if (blockedMongooseProperties.has(prop)) throw new Error(`ACL-protected Mongoose property .${String(prop)} is blocked. Use models.getUnsafe(...) explicitly.`);
+				if (blockedMongooseMethods.has(prop)) return () => {
+					throw new Error(`ACL-protected Mongoose method ${String(prop)}() is blocked. Use models.getUnsafe(...) explicitly.`);
+				};
+				const value = Reflect.get(target, prop, target);
+				if (typeof value !== "function") return value;
+				return (...args) => {
+					const result = Reflect.apply(value, target, args);
+					return result === target ? mongooseProxy : result;
+				};
+			},
+			set(_target, prop) {
+				throw new Error(`ACL-protected Mongoose property .${String(prop)} cannot be changed. Use models.getUnsafe(...) explicitly.`);
+			}
+		});
+		return mongooseProxy;
+	};
+	const createCollectionProxy = (collection) => {
+		if (context.mode === "unsafe") return collection;
+		const proxy = new Proxy(collection, {
+			get(target, prop) {
+				if (prop === "conn") return connectionProxy;
+				if (blockedCollectionProperties.has(prop)) throw new Error(`ACL-protected collection property .${String(prop)} is blocked. Use models.getUnsafe(...) explicitly.`);
+				const value = Reflect.get(target, prop, target);
+				if (typeof value !== "function") return value;
+				return (...args) => {
+					const result = Reflect.apply(value, target, args);
+					return result === target ? proxy : result;
+				};
+			},
+			set(_target, prop) {
+				throw new Error(`ACL-protected collection property .${String(prop)} cannot be changed. Use models.getUnsafe(...) explicitly.`);
+			}
+		});
+		collectionTargets.set(proxy, collection);
+		return proxy;
+	};
+	const getCollection = (collectionName, options = {}) => {
+		const existing = collections.get(collectionName);
+		if (existing) return existing;
+		const modelName = collectionName === primaryCollectionName ? model.modelName : resolveModelNameForCollection(rawConnection, collectionName);
+		if (context.mode !== "unsafe" && collectionName !== primaryCollectionName && (!modelName || !hasRegisteredPolicy(modelName))) throw new Error(`ACL-protected connections cannot access collection "${collectionName}" without a protected model. Load that model explicitly or use models.getUnsafe(...).`);
+		const collection = new AclMongooseCollection(collectionName, rawConnection, {
+			...options,
+			modelName
+		});
+		bindMongooseAclDriverContext(collection, context);
+		const exposedCollection = createCollectionProxy(collection);
+		collections.set(collectionName, exposedCollection);
+		return exposedCollection;
+	};
+	const getRelatedModel = (modelName) => {
+		return createAclModelWithContext(rawConnection.model(modelName), context);
+	};
+	const getModelsProxy = () => {
+		if (modelsProxy) return modelsProxy;
+		modelsProxy = new Proxy(rawConnection.models, {
+			get(target, prop, receiver) {
+				const value = Reflect.get(target, prop, receiver);
+				return typeof prop === "string" && Object.hasOwn(target, prop) && value && typeof value === "function" ? getRelatedModel(prop) : value;
+			},
+			set(target, prop, value, receiver) {
+				if (context.mode === "unsafe") return Reflect.set(target, prop, value, receiver);
+				throw new Error(`ACL-protected connection model .${String(prop)} cannot be changed.`);
+			},
+			deleteProperty(target, prop) {
+				if (context.mode === "unsafe") return Reflect.deleteProperty(target, prop);
+				throw new Error(`ACL-protected connection model .${String(prop)} cannot be deleted.`);
+			}
+		});
+		return modelsProxy;
+	};
+	const getCollectionsProxy = () => {
+		if (collectionsProxy) return collectionsProxy;
+		collectionsProxy = new Proxy(rawConnection.collections, {
+			get(target, prop, receiver) {
+				const value = Reflect.get(target, prop, receiver);
+				return typeof prop === "string" && Object.hasOwn(target, prop) && value ? getCollection(prop) : value;
+			},
+			set(target, prop, value, receiver) {
+				if (context.mode === "unsafe") return Reflect.set(target, prop, value, receiver);
+				throw new Error(`ACL-protected connection collection .${String(prop)} cannot be changed.`);
+			},
+			deleteProperty(target, prop) {
+				if (context.mode === "unsafe") return Reflect.deleteProperty(target, prop);
+				throw new Error(`ACL-protected connection collection .${String(prop)} cannot be deleted.`);
+			}
+		});
+		return collectionsProxy;
+	};
+	const getDbProxy = () => {
+		const rawDb = rawConnection.db;
+		if (!rawDb || context.mode === "unsafe") return rawDb;
+		if (dbProxy) return dbProxy;
+		dbProxy = new Proxy(rawDb, {
+			get(target, prop) {
+				if (prop === "collection") return (collectionName) => getCollection(collectionName).collection;
+				if (allowedDbProperties.has(prop)) return Reflect.get(target, prop, target);
+				throw new Error(`ACL-protected database access .${String(prop)} is blocked. Use models.getUnsafe(...) explicitly.`);
+			},
+			set(_target, prop) {
+				throw new Error(`ACL-protected database property .${String(prop)} cannot be changed. Use models.getUnsafe(...) explicitly.`);
+			}
+		});
+		return dbProxy;
+	};
+	const connectionProxy = new Proxy(rawConnection, {
+		get(target, prop) {
+			if (prop === "collection") return getCollection;
+			if (prop === "collections") return getCollectionsProxy();
+			if (prop === "models") return getModelsProxy();
+			if (prop === "db") return getDbProxy();
+			if (prop === "base") return getMongooseProxy();
+			if (context.mode !== "unsafe" && blockedConnectionProperties.has(prop)) throw new Error(`ACL-protected connection property .${String(prop)} is blocked. Use models.getUnsafe(...) explicitly.`);
+			if (prop === "getClient") {
+				if (context.mode === "unsafe") return target.getClient.bind(target);
+				return () => {
+					throw new Error("ACL-protected MongoClient access is blocked. Use models.getUnsafe(...) explicitly.");
+				};
+			}
+			if (prop === "model") return (modelName, ...args) => {
+				if (context.mode !== "unsafe" && args.length > 0) throw new Error("ACL-protected connections cannot compile models. Use models.getUnsafe(...) explicitly.");
+				return createAclModelWithContext(Reflect.apply(target.model, target, [modelName, ...args]), context);
+			};
+			if (context.mode !== "unsafe" && blockedConnectionMethods.has(prop)) return () => {
+				throw new Error(`ACL-protected connection method ${String(prop)}() is blocked. Use models.getUnsafe(...) explicitly.`);
+			};
+			const value = Reflect.get(target, prop, target);
+			if (typeof value !== "function") return value;
+			return (...args) => {
+				const result = Reflect.apply(value, target, args);
+				if (result === target) return connectionProxy;
+				if (result && typeof result === "object" && "then" in result) {
+					if (typeof result.then === "function") return Promise.resolve(result).then((resolved) => resolved === target ? connectionProxy : resolved);
+				}
+				return result;
+			};
+		},
+		set(target, prop, value, receiver) {
+			if (context.mode === "unsafe") return Reflect.set(target, prop, value, receiver);
+			throw new Error(`ACL-protected connection property .${String(prop)} cannot be changed. Use models.getUnsafe(...) explicitly.`);
+		}
+	});
+	bindMongooseAclRawConnection(connectionProxy, rawConnection);
+	const scopedModel = model.__subclass(connectionProxy, model.schema, primaryCollectionName);
+	detachMongooseSubclassRetention(model, scopedModel);
+	cacheModel(model, scopedModel, context);
+	Object.defineProperty(scopedModel, "acl", {
+		configurable: false,
+		value: (ability) => createAclModelWithContext(model, {
+			mode: "ability",
+			ability
+		})
+	});
+	if (context.mode !== "unsafe") {
+		const scopedCollection = scopedModel.collection;
+		lockModelCapability(scopedModel, "base", getMongooseProxy());
+		lockModelCapability(scopedModel, "db", connectionProxy);
+		lockModelCapability(scopedModel, "collection", scopedCollection);
+		lockModelCapability(scopedModel, "$__collection", scopedCollection);
+		lockModelCapability(scopedModel.prototype, "db", connectionProxy);
+		lockModelCapability(scopedModel.prototype, "collection", scopedCollection);
+		lockModelCapability(scopedModel.prototype, "$collection", scopedCollection);
+	}
+	const rawDiscriminators = model.discriminators;
+	if (rawDiscriminators) {
+		const generatedDiscriminators = scopedModel.discriminators ?? {};
+		const scopedDiscriminators = {};
+		for (const [name, discriminator] of Object.entries(rawDiscriminators)) {
+			const generated = generatedDiscriminators[name];
+			if (generated) detachMongooseSubclassRetention(discriminator, generated);
+			scopedDiscriminators[name] = createAclModelWithContext(discriminator, context);
+		}
+		scopedModel.discriminators = scopedDiscriminators;
+	}
+	if (context.mode !== "unsafe") {
+		for (const methodName of blockedModelMethods) Object.defineProperty(scopedModel, methodName, {
+			configurable: false,
+			value: () => {
+				throw new Error(`ACL-protected model method ${String(methodName)}() is blocked. Use models.getUnsafe(...) explicitly.`);
+			}
+		});
+		Object.defineProperty(scopedModel, "discriminator", {
+			configurable: false,
+			value: () => {
+				throw new Error("ACL-protected models cannot compile discriminators. Define them before models.get(...).");
+			}
+		});
+	}
+	return scopedModel;
+};
+installMongooseAclDriver();
+var createAclMongooseModel = (model, ability) => createAclModelWithContext(model, {
+	mode: "ability",
+	ability
+});
+var createAclMongooseModelGateway = (model) => createAclModelWithContext(model, unboundMongooseAclDriverContext);
+var createUnsafeMongooseModel = (model) => createAclModelWithContext(model, unsafeMongooseAclDriverContext);
+var installMongooseAclModelFactory = () => {
+	const modelConstructor = mongoose$1.Model;
+	if (Object.hasOwn(modelConstructor, "acl")) return;
+	Object.defineProperty(modelConstructor, "acl", {
+		configurable: false,
+		value: function(ability) {
+			return createAclMongooseModel(this, ability);
+		}
+	});
+};
+installMongooseAclModelFactory();
+//#endregion
 //#region src/modelsApi.ts
 var loadModelFromDb = async (modelName, dbName, scope) => {
 	const schemas = getRegisteredModels(scope);
 	const schema = schemas[modelName];
 	assert(schema, `Model ${modelName} not registered. Available models: ${Object.keys(schemas).join(", ")}`);
 	const modelConnection = await ensureMongooseConnection(dbName);
-	if (!modelConnection.models[modelName]) modelConnection.model(modelName, schema);
+	if (!modelConnection.models[modelName]) await runWithUnsafeMongooseAclDriver(async () => {
+		await modelConnection.model(modelName, schema).init();
+	});
 	return modelConnection.models[modelName];
 };
 var normalizeTenantId$1 = (value) => {
@@ -2037,15 +2900,11 @@ var getTenantIdFromLoadModelCtx = (ctx) => {
 var models = {
 	register: registerModels,
 	getUnsafe: async (modelName, ctx) => {
-		return loadModelFromDb(modelName, getTenantDbName(getTenantIdFromLoadModelCtx(ctx)), "tenant");
+		return createUnsafeMongooseModel(await loadModelFromDb(modelName, getTenantDbName(getTenantIdFromLoadModelCtx(ctx)), "tenant"));
 	},
 	get: async (modelName, ctx) => {
-		const model = await models.getUnsafe(modelName, ctx);
-		const resolvedAbility = ctx.ability;
-		if (!hasRegisteredPolicy(modelName)) return model;
-		if (!resolvedAbility) throw new Error(`Model "${modelName}" is ACL-protected. Set ctx.ability or use models.getUnsafe(...) explicitly.`);
-		if (typeof model.acl !== "function") return model;
-		return model.acl(resolvedAbility);
+		const model = await loadModelFromDb(modelName, getTenantDbName(getTenantIdFromLoadModelCtx(ctx)), "tenant");
+		return ctx.ability ? createAclMongooseModel(model, ctx.ability) : createAclMongooseModelGateway(model);
 	},
 	getGlobal: async (modelName, ctx) => {
 		return loadModelFromDb(modelName, getGlobalDbName(), "global");