@rpcbase/db 0.86.0 → 0.88.0

package/dist/index.js

@@ -1,1820 +1,2120 @@
-import { buildAbility, buildAbilityFromSession, can, getAccessibleByQuery, getRegisteredPolicies, getTenantRolesFromSessionUser, hasRegisteredPolicy, registerPoliciesFromModules, registerPolicy } from "./acl/index.js";
-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-Co_dG17m.js";
-import "./model.js";
-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 { createHmac, timingSafeEqual } from "node:crypto";
+import { r as registerPoliciesFromModules, h as hasRegisteredPolicy } from "./can-B4pD_pnR.js";
+import { b, a, c, g, d, e, f } from "./can-B4pD_pnR.js";
+import mongoose, { Schema as Schema$1, Types } from "mongoose";
+import { default as default2 } from "mongoose";
+import { z } from "zod";
+import { timingSafeEqual, createHmac } from "node:crypto";
+import { w as withLocalizedStringFallback } from "./index-BQeL_LHp.js";
+import { E, a as a2, L, b as b2, e as e2, m, r, z as z2, c as c2, d as d2, f as f2 } from "./index-BQeL_LHp.js";
 import assert from "assert";
-//#region \0rolldown/runtime.js
-var __defProp = Object.defineProperty;
-var __exportAll = (all, no_symbols) => {
-	let target = {};
-	for (var name in all) __defProp(target, name, {
-		get: all[name],
-		enumerable: true
-	});
-	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
-	return target;
-};
-//#endregion
-//#region src/models/RBUser.ts
-var ZRBUser = z$1.object({
-	email: z$1.string().email().optional(),
-	password: z$1.string(),
-	name: z$1.string().optional(),
-	phone: z$1.string().optional(),
-	tenants: z$1.array(z$1.string()),
-	tenantRoles: z$1.record(z$1.string(), z$1.array(z$1.string())).optional(),
-	oauthProviders: z$1.record(z$1.string(), z$1.object({
-		subject: z$1.string(),
-		email: z$1.string().email().optional(),
-		name: z$1.string().optional(),
-		accessToken: z$1.string().optional(),
-		refreshToken: z$1.string().optional(),
-		idToken: z$1.string().optional(),
-		scope: z$1.string().optional(),
-		tokenType: z$1.string().optional(),
-		expiresAt: z$1.date().optional(),
-		rawUserInfo: z$1.unknown().optional(),
-		createdAt: z$1.date().optional(),
-		updatedAt: z$1.date().optional()
-	})).optional(),
-	emailVerificationCode: z$1.string().length(6).optional(),
-	emailVerificationExpiresAt: z$1.date().optional(),
-	passwordResetCode: z$1.string().length(6).optional(),
-	passwordResetCodeExpiresAt: z$1.date().optional(),
-	passwordResetToken: z$1.string().optional(),
-	passwordResetTokenExpiresAt: z$1.date().optional()
+import { accessibleBy, accessibleRecordsPlugin } from "@casl/mongoose";
+import "@casl/ability";
+const ZRBUser = z.object({
+  email: z.string().email().optional(),
+  password: z.string(),
+  name: z.string().optional(),
+  phone: z.string().optional(),
+  tenants: z.array(z.string()),
+  tenantRoles: z.record(z.string(), z.array(z.string())).optional(),
+  oauthProviders: z.record(z.string(), z.object({
+    subject: z.string(),
+    email: z.string().email().optional(),
+    name: z.string().optional(),
+    accessToken: z.string().optional(),
+    refreshToken: z.string().optional(),
+    idToken: z.string().optional(),
+    scope: z.string().optional(),
+    tokenType: z.string().optional(),
+    expiresAt: z.date().optional(),
+    rawUserInfo: z.unknown().optional(),
+    createdAt: z.date().optional(),
+    updatedAt: z.date().optional()
+  })).optional(),
+  emailVerificationCode: z.string().length(6).optional(),
+  emailVerificationExpiresAt: z.date().optional(),
+  passwordResetCode: z.string().length(6).optional(),
+  passwordResetCodeExpiresAt: z.date().optional(),
+  passwordResetToken: z.string().optional(),
+  passwordResetTokenExpiresAt: z.date().optional()
 });
-var RBUserSchema = new Schema$1({
-	email: {
-		type: String,
-		unique: true,
-		sparse: true
-	},
-	phone: {
-		type: String,
-		unique: true,
-		sparse: true
-	},
-	password: {
-		type: String,
-		required: true
-	},
-	name: String,
-	tenants: {
-		type: [String],
-		index: true,
-		required: true
-	},
-	tenantRoles: {
-		type: Map,
-		of: [String],
-		required: false,
-		default: {}
-	},
-	oauthProviders: {
-		type: Map,
-		of: new Schema$1({
-			subject: {
-				type: String,
-				required: true
-			},
-			email: {
-				type: String,
-				required: false
-			},
-			name: {
-				type: String,
-				required: false
-			},
-			accessToken: {
-				type: String,
-				required: false
-			},
-			refreshToken: {
-				type: String,
-				required: false
-			},
-			idToken: {
-				type: String,
-				required: false
-			},
-			scope: {
-				type: String,
-				required: false
-			},
-			tokenType: {
-				type: String,
-				required: false
-			},
-			expiresAt: {
-				type: Date,
-				required: false
-			},
-			rawUserInfo: {
-				type: Schema$1.Types.Mixed,
-				required: false
-			},
-			createdAt: {
-				type: Date,
-				required: false
-			},
-			updatedAt: {
-				type: Date,
-				required: false
-			}
-		}, { _id: false }),
-		default: {},
-		required: false
-	},
-	emailVerificationCode: {
-		type: String,
-		required: false
-	},
-	emailVerificationExpiresAt: {
-		type: Date,
-		required: false
-	},
-	passwordResetCode: {
-		type: String,
-		required: false
-	},
-	passwordResetCodeExpiresAt: {
-		type: Date,
-		required: false
-	},
-	passwordResetToken: {
-		type: String,
-		required: false
-	},
-	passwordResetTokenExpiresAt: {
-		type: Date,
-		required: false
-	}
+const RBUserSchema = new Schema$1({
+  email: {
+    type: String,
+    unique: true,
+    sparse: true
+  },
+  phone: {
+    type: String,
+    unique: true,
+    sparse: true
+  },
+  password: {
+    type: String,
+    required: true
+  },
+  name: String,
+  tenants: {
+    type: [String],
+    index: true,
+    required: true
+  },
+  tenantRoles: {
+    type: Map,
+    of: [String],
+    required: false,
+    default: {}
+  },
+  oauthProviders: {
+    type: Map,
+    of: new Schema$1({
+      subject: {
+        type: String,
+        required: true
+      },
+      email: {
+        type: String,
+        required: false
+      },
+      name: {
+        type: String,
+        required: false
+      },
+      accessToken: {
+        type: String,
+        required: false
+      },
+      refreshToken: {
+        type: String,
+        required: false
+      },
+      idToken: {
+        type: String,
+        required: false
+      },
+      scope: {
+        type: String,
+        required: false
+      },
+      tokenType: {
+        type: String,
+        required: false
+      },
+      expiresAt: {
+        type: Date,
+        required: false
+      },
+      rawUserInfo: {
+        type: Schema$1.Types.Mixed,
+        required: false
+      },
+      createdAt: {
+        type: Date,
+        required: false
+      },
+      updatedAt: {
+        type: Date,
+        required: false
+      }
+    }, {
+      _id: false
+    }),
+    default: {},
+    required: false
+  },
+  emailVerificationCode: {
+    type: String,
+    required: false
+  },
+  emailVerificationExpiresAt: {
+    type: Date,
+    required: false
+  },
+  passwordResetCode: {
+    type: String,
+    required: false
+  },
+  passwordResetCodeExpiresAt: {
+    type: Date,
+    required: false
+  },
+  passwordResetToken: {
+    type: String,
+    required: false
+  },
+  passwordResetTokenExpiresAt: {
+    type: Date,
+    required: false
+  }
 });
-//#endregion
-//#region src/models/RBTenant.ts
-var ZRBTenant = z$1.object({
-	tenantId: z$1.string(),
-	parentTenantId: z$1.string().optional(),
-	name: z$1.string().optional()
+const ZRBTenant = z.object({
+  tenantId: z.string(),
+  parentTenantId: z.string().optional(),
+  name: z.string().optional()
 });
-var RBTenantSchema = new Schema$1({
-	tenantId: {
-		type: String,
-		required: true,
-		unique: true,
-		index: true
-	},
-	parentTenantId: { type: String },
-	name: { type: String }
+const RBTenantSchema = new Schema$1({
+  tenantId: {
+    type: String,
+    required: true,
+    unique: true,
+    index: true
+  },
+  parentTenantId: {
+    type: String
+  },
+  name: {
+    type: String
+  }
 });
-//#endregion
-//#region src/models/RBTenantSubscription.ts
-var ZRBTenantSubscriptionStatus = z$1.enum([
-	"trialing",
-	"active",
-	"past_due",
-	"paused",
-	"canceled",
-	"expired"
-]);
-var ZRBTenantSubscriptionIntervalUnit = z$1.enum(["month", "year"]);
-var ZRBTenantSubscriptionType = z$1.enum(["primary", "addon"]);
-var ZRBTenantSubscriptionScope = z$1.enum([
-	"tenant",
-	"shop",
-	"custom"
-]);
-var ZRBTenantSubscription = z$1.object({
-	tenantId: z$1.string(),
-	subscriptionId: z$1.string(),
-	type: ZRBTenantSubscriptionType.optional(),
-	parentSubscriptionId: z$1.string().optional(),
-	scope: ZRBTenantSubscriptionScope.optional(),
-	scopeId: z$1.string().optional(),
-	planKey: z$1.string(),
-	status: ZRBTenantSubscriptionStatus,
-	intervalUnit: ZRBTenantSubscriptionIntervalUnit,
-	intervalCount: z$1.number().int().min(1).optional(),
-	modules: z$1.array(z$1.string()).optional(),
-	currentPeriodStart: z$1.date().optional(),
-	currentPeriodEnd: z$1.date().optional(),
-	trialEndsAt: z$1.date().optional(),
-	cancelAt: z$1.date().optional(),
-	cancelAtPeriodEnd: z$1.boolean().optional(),
-	canceledAt: z$1.date().optional(),
-	provider: z$1.string().optional(),
-	providerCustomerId: z$1.string().optional(),
-	providerSubscriptionId: z$1.string().optional(),
-	latestEventId: z$1.string().optional(),
-	latestEventAt: z$1.date().optional(),
-	metadata: z$1.record(z$1.string(), z$1.unknown()).optional()
+const ZRBTenantSubscriptionStatus = z.enum(["trialing", "active", "past_due", "paused", "canceled", "expired"]);
+const ZRBTenantSubscriptionIntervalUnit = z.enum(["month", "year"]);
+const ZRBTenantSubscriptionType = z.enum(["primary", "addon"]);
+const ZRBTenantSubscriptionScope = z.enum(["tenant", "shop", "custom"]);
+const ZRBTenantSubscription = z.object({
+  tenantId: z.string(),
+  subscriptionId: z.string(),
+  type: ZRBTenantSubscriptionType.optional(),
+  parentSubscriptionId: z.string().optional(),
+  scope: ZRBTenantSubscriptionScope.optional(),
+  scopeId: z.string().optional(),
+  planKey: z.string(),
+  status: ZRBTenantSubscriptionStatus,
+  intervalUnit: ZRBTenantSubscriptionIntervalUnit,
+  intervalCount: z.number().int().min(1).optional(),
+  modules: z.array(z.string()).optional(),
+  currentPeriodStart: z.date().optional(),
+  currentPeriodEnd: z.date().optional(),
+  trialEndsAt: z.date().optional(),
+  cancelAt: z.date().optional(),
+  cancelAtPeriodEnd: z.boolean().optional(),
+  canceledAt: z.date().optional(),
+  provider: z.string().optional(),
+  providerCustomerId: z.string().optional(),
+  providerSubscriptionId: z.string().optional(),
+  latestEventId: z.string().optional(),
+  latestEventAt: z.date().optional(),
+  metadata: z.record(z.string(), z.unknown()).optional()
 });
-var RBTenantSubscriptionSchema = new Schema$1({
-	tenantId: {
-		type: String,
-		required: true,
-		index: true
-	},
-	subscriptionId: {
-		type: String,
-		required: true
-	},
-	type: {
-		type: String,
-		required: true,
-		enum: ZRBTenantSubscriptionType.options,
-		default: "primary"
-	},
-	parentSubscriptionId: { type: String },
-	scope: {
-		type: String,
-		enum: ZRBTenantSubscriptionScope.options,
-		default: "tenant"
-	},
-	scopeId: { type: String },
-	planKey: {
-		type: String,
-		required: true
-	},
-	status: {
-		type: String,
-		required: true,
-		enum: ZRBTenantSubscriptionStatus.options
-	},
-	intervalUnit: {
-		type: String,
-		required: true,
-		enum: ZRBTenantSubscriptionIntervalUnit.options
-	},
-	intervalCount: {
-		type: Number,
-		min: 1,
-		default: 1
-	},
-	modules: {
-		type: [String],
-		default: []
-	},
-	currentPeriodStart: { type: Date },
-	currentPeriodEnd: { type: Date },
-	trialEndsAt: { type: Date },
-	cancelAt: { type: Date },
-	cancelAtPeriodEnd: {
-		type: Boolean,
-		default: false
-	},
-	canceledAt: { type: Date },
-	provider: { type: String },
-	providerCustomerId: { type: String },
-	providerSubscriptionId: { type: String },
-	latestEventId: { type: String },
-	latestEventAt: { type: Date },
-	metadata: { type: Schema$1.Types.Mixed }
+const RBTenantSubscriptionSchema = new Schema$1({
+  tenantId: {
+    type: String,
+    required: true,
+    index: true
+  },
+  subscriptionId: {
+    type: String,
+    required: true
+  },
+  type: {
+    type: String,
+    required: true,
+    enum: ZRBTenantSubscriptionType.options,
+    default: "primary"
+  },
+  parentSubscriptionId: {
+    type: String
+  },
+  scope: {
+    type: String,
+    enum: ZRBTenantSubscriptionScope.options,
+    default: "tenant"
+  },
+  scopeId: {
+    type: String
+  },
+  planKey: {
+    type: String,
+    required: true
+  },
+  status: {
+    type: String,
+    required: true,
+    enum: ZRBTenantSubscriptionStatus.options
+  },
+  intervalUnit: {
+    type: String,
+    required: true,
+    enum: ZRBTenantSubscriptionIntervalUnit.options
+  },
+  intervalCount: {
+    type: Number,
+    min: 1,
+    default: 1
+  },
+  modules: {
+    type: [String],
+    default: []
+  },
+  currentPeriodStart: {
+    type: Date
+  },
+  currentPeriodEnd: {
+    type: Date
+  },
+  trialEndsAt: {
+    type: Date
+  },
+  cancelAt: {
+    type: Date
+  },
+  cancelAtPeriodEnd: {
+    type: Boolean,
+    default: false
+  },
+  canceledAt: {
+    type: Date
+  },
+  provider: {
+    type: String
+  },
+  providerCustomerId: {
+    type: String
+  },
+  providerSubscriptionId: {
+    type: String
+  },
+  latestEventId: {
+    type: String
+  },
+  latestEventAt: {
+    type: Date
+  },
+  metadata: {
+    type: Schema$1.Types.Mixed
+  }
 });
 RBTenantSubscriptionSchema.index({
-	tenantId: 1,
-	subscriptionId: 1
-}, { unique: true });
+  tenantId: 1,
+  subscriptionId: 1
+}, {
+  unique: true
+});
 RBTenantSubscriptionSchema.index({
-	tenantId: 1,
-	scope: 1,
-	scopeId: 1
+  tenantId: 1,
+  scope: 1,
+  scopeId: 1
 });
-//#endregion
-//#region src/models/RBTenantSubscriptionEvent.ts
-var ZRBTenantSubscriptionEventSource = z$1.enum([
-	"admin",
-	"system",
-	"webhook",
-	"user"
-]);
-var ZRBTenantSubscriptionChangeDirection = z$1.enum([
-	"upgrade",
-	"downgrade",
-	"lateral"
-]);
-var ZRBTenantSubscriptionEvent = z$1.object({
-	tenantId: z$1.string(),
-	subscriptionId: z$1.string(),
-	type: z$1.string(),
-	occurredAt: z$1.date(),
-	effectiveAt: z$1.date().optional(),
-	fromPlanKey: z$1.string().optional(),
-	toPlanKey: z$1.string().optional(),
-	fromStatus: ZRBTenantSubscriptionStatus.optional(),
-	toStatus: ZRBTenantSubscriptionStatus.optional(),
-	fromModules: z$1.array(z$1.string()).optional(),
-	toModules: z$1.array(z$1.string()).optional(),
-	fromIntervalUnit: ZRBTenantSubscriptionIntervalUnit.optional(),
-	toIntervalUnit: ZRBTenantSubscriptionIntervalUnit.optional(),
-	fromIntervalCount: z$1.number().int().min(1).optional(),
-	toIntervalCount: z$1.number().int().min(1).optional(),
-	direction: ZRBTenantSubscriptionChangeDirection.optional(),
-	actorUserId: z$1.string().optional(),
-	source: ZRBTenantSubscriptionEventSource.optional(),
-	reason: z$1.string().optional(),
-	provider: z$1.string().optional(),
-	providerEventId: z$1.string().optional(),
-	providerPayload: z$1.unknown().optional(),
-	metadata: z$1.record(z$1.string(), z$1.unknown()).optional()
+const ZRBTenantSubscriptionEventSource = z.enum(["admin", "system", "webhook", "user"]);
+const ZRBTenantSubscriptionChangeDirection = z.enum(["upgrade", "downgrade", "lateral"]);
+const ZRBTenantSubscriptionEvent = z.object({
+  tenantId: z.string(),
+  subscriptionId: z.string(),
+  type: z.string(),
+  occurredAt: z.date(),
+  effectiveAt: z.date().optional(),
+  fromPlanKey: z.string().optional(),
+  toPlanKey: z.string().optional(),
+  fromStatus: ZRBTenantSubscriptionStatus.optional(),
+  toStatus: ZRBTenantSubscriptionStatus.optional(),
+  fromModules: z.array(z.string()).optional(),
+  toModules: z.array(z.string()).optional(),
+  fromIntervalUnit: ZRBTenantSubscriptionIntervalUnit.optional(),
+  toIntervalUnit: ZRBTenantSubscriptionIntervalUnit.optional(),
+  fromIntervalCount: z.number().int().min(1).optional(),
+  toIntervalCount: z.number().int().min(1).optional(),
+  direction: ZRBTenantSubscriptionChangeDirection.optional(),
+  actorUserId: z.string().optional(),
+  source: ZRBTenantSubscriptionEventSource.optional(),
+  reason: z.string().optional(),
+  provider: z.string().optional(),
+  providerEventId: z.string().optional(),
+  providerPayload: z.unknown().optional(),
+  metadata: z.record(z.string(), z.unknown()).optional()
 });
-var RBTenantSubscriptionEventSchema = new Schema$1({
-	tenantId: {
-		type: String,
-		required: true,
-		index: true
-	},
-	subscriptionId: {
-		type: String,
-		required: true,
-		index: true
-	},
-	type: {
-		type: String,
-		required: true
-	},
-	occurredAt: {
-		type: Date,
-		required: true,
-		default: Date.now
-	},
-	effectiveAt: { type: Date },
-	fromPlanKey: { type: String },
-	toPlanKey: { type: String },
-	fromStatus: {
-		type: String,
-		enum: ZRBTenantSubscriptionStatus.options
-	},
-	toStatus: {
-		type: String,
-		enum: ZRBTenantSubscriptionStatus.options
-	},
-	fromModules: {
-		type: [String],
-		default: void 0
-	},
-	toModules: {
-		type: [String],
-		default: void 0
-	},
-	fromIntervalUnit: {
-		type: String,
-		enum: ZRBTenantSubscriptionIntervalUnit.options
-	},
-	toIntervalUnit: {
-		type: String,
-		enum: ZRBTenantSubscriptionIntervalUnit.options
-	},
-	fromIntervalCount: {
-		type: Number,
-		min: 1
-	},
-	toIntervalCount: {
-		type: Number,
-		min: 1
-	},
-	direction: {
-		type: String,
-		enum: ZRBTenantSubscriptionChangeDirection.options
-	},
-	actorUserId: { type: String },
-	source: {
-		type: String,
-		enum: ZRBTenantSubscriptionEventSource.options
-	},
-	reason: { type: String },
-	provider: { type: String },
-	providerEventId: { type: String },
-	providerPayload: { type: Schema$1.Types.Mixed },
-	metadata: { type: Schema$1.Types.Mixed }
+const RBTenantSubscriptionEventSchema = new Schema$1({
+  tenantId: {
+    type: String,
+    required: true,
+    index: true
+  },
+  subscriptionId: {
+    type: String,
+    required: true,
+    index: true
+  },
+  type: {
+    type: String,
+    required: true
+  },
+  occurredAt: {
+    type: Date,
+    required: true,
+    default: Date.now
+  },
+  effectiveAt: {
+    type: Date
+  },
+  fromPlanKey: {
+    type: String
+  },
+  toPlanKey: {
+    type: String
+  },
+  fromStatus: {
+    type: String,
+    enum: ZRBTenantSubscriptionStatus.options
+  },
+  toStatus: {
+    type: String,
+    enum: ZRBTenantSubscriptionStatus.options
+  },
+  fromModules: {
+    type: [String],
+    default: void 0
+  },
+  toModules: {
+    type: [String],
+    default: void 0
+  },
+  fromIntervalUnit: {
+    type: String,
+    enum: ZRBTenantSubscriptionIntervalUnit.options
+  },
+  toIntervalUnit: {
+    type: String,
+    enum: ZRBTenantSubscriptionIntervalUnit.options
+  },
+  fromIntervalCount: {
+    type: Number,
+    min: 1
+  },
+  toIntervalCount: {
+    type: Number,
+    min: 1
+  },
+  direction: {
+    type: String,
+    enum: ZRBTenantSubscriptionChangeDirection.options
+  },
+  actorUserId: {
+    type: String
+  },
+  source: {
+    type: String,
+    enum: ZRBTenantSubscriptionEventSource.options
+  },
+  reason: {
+    type: String
+  },
+  provider: {
+    type: String
+  },
+  providerEventId: {
+    type: String
+  },
+  providerPayload: {
+    type: Schema$1.Types.Mixed
+  },
+  metadata: {
+    type: Schema$1.Types.Mixed
+  }
 });
 RBTenantSubscriptionEventSchema.index({
-	tenantId: 1,
-	subscriptionId: 1,
-	occurredAt: 1
+  tenantId: 1,
+  subscriptionId: 1,
+  occurredAt: 1
 });
 RBTenantSubscriptionEventSchema.index({
-	provider: 1,
-	providerEventId: 1
+  provider: 1,
+  providerEventId: 1
+}, {
+  unique: true,
+  sparse: true
+});
+const ZRBRtsCounter = z.object({
+  _id: z.string(),
+  seq: z.number().int().min(0)
+});
+const RBRtsCounterSchema = new Schema$1({
+  _id: {
+    type: String,
+    required: true
+  },
+  seq: {
+    type: Number,
+    required: true,
+    default: 0
+  }
 }, {
-	unique: true,
-	sparse: true
+  versionKey: false
 });
-//#endregion
-//#region src/models/RBRtsCounter.ts
-var ZRBRtsCounter = z$1.object({
-	_id: z$1.string(),
-	seq: z$1.number().int().min(0)
+const ttlSecondsRaw = process.env.RB_RTS_CHANGES_TTL_S ?? "";
+const ttlSeconds = Number.isFinite(Number(ttlSecondsRaw)) ? Math.max(60, Math.floor(Number(ttlSecondsRaw))) : 60 * 60 * 24 * 30;
+const ZRBRtsChangeOp = z.enum(["delete", "reset_model"]);
+const ZRBRtsChange = z.object({
+  seq: z.number().int().min(0),
+  modelName: z.string(),
+  op: ZRBRtsChangeOp,
+  docId: z.string().optional(),
+  ts: z.date()
 });
-var RBRtsCounterSchema = new Schema$1({
-	_id: {
-		type: String,
-		required: true
-	},
-	seq: {
-		type: Number,
-		required: true,
-		default: 0
-	}
-}, { versionKey: false });
-//#endregion
-//#region src/models/RBRtsChange.ts
-var ttlSecondsRaw = process.env.RB_RTS_CHANGES_TTL_S ?? "";
-var ttlSeconds = Number.isFinite(Number(ttlSecondsRaw)) ? Math.max(60, Math.floor(Number(ttlSecondsRaw))) : 3600 * 24 * 30;
-var ZRBRtsChangeOp = z$1.enum(["delete", "reset_model"]);
-var ZRBRtsChange = z$1.object({
-	seq: z$1.number().int().min(0),
-	modelName: z$1.string(),
-	op: ZRBRtsChangeOp,
-	docId: z$1.string().optional(),
-	ts: z$1.date()
+const RBRtsChangeSchema = new Schema$1({
+  seq: {
+    type: Number,
+    required: true
+  },
+  modelName: {
+    type: String,
+    required: true,
+    index: true
+  },
+  op: {
+    type: String,
+    required: true,
+    enum: ZRBRtsChangeOp.options
+  },
+  docId: {
+    type: String,
+    required: false
+  },
+  ts: {
+    type: Date,
+    required: true,
+    default: Date.now
+  }
+}, {
+  versionKey: false
+});
+RBRtsChangeSchema.index({
+  seq: 1
+}, {
+  unique: true
 });
-var RBRtsChangeSchema = new Schema$1({
-	seq: {
-		type: Number,
-		required: true
-	},
-	modelName: {
-		type: String,
-		required: true,
-		index: true
-	},
-	op: {
-		type: String,
-		required: true,
-		enum: ZRBRtsChangeOp.options
-	},
-	docId: {
-		type: String,
-		required: false
-	},
-	ts: {
-		type: Date,
-		required: true,
-		default: Date.now
-	}
-}, { versionKey: false });
-RBRtsChangeSchema.index({ seq: 1 }, { unique: true });
-RBRtsChangeSchema.index({ ts: 1 }, { expireAfterSeconds: ttlSeconds });
-//#endregion
-//#region src/models/RBUploadSession.ts
-var ZRBUploadSessionStatus = z$1.enum([
-	"uploading",
-	"assembling",
-	"done",
-	"error"
-]);
-var ZRBUploadSession = z$1.object({
-	_id: z$1.string(),
-	userId: z$1.string().optional(),
-	ownerKeyHash: z$1.string().optional(),
-	filename: z$1.string(),
-	mimeType: z$1.string(),
-	totalSize: z$1.number().int().min(0),
-	chunkSize: z$1.number().int().min(1),
-	chunksTotal: z$1.number().int().min(1),
-	status: ZRBUploadSessionStatus,
-	createdAt: z$1.date(),
-	expiresAt: z$1.date(),
-	fileId: z$1.string().optional(),
-	isPublic: z$1.boolean().optional(),
-	error: z$1.string().optional()
+RBRtsChangeSchema.index({
+  ts: 1
+}, {
+  expireAfterSeconds: ttlSeconds
+});
+const ZRBUploadSessionStatus = z.enum(["uploading", "assembling", "done", "error"]);
+const ZRBUploadSession = z.object({
+  _id: z.string(),
+  userId: z.string().optional(),
+  ownerKeyHash: z.string().optional(),
+  filename: z.string(),
+  mimeType: z.string(),
+  totalSize: z.number().int().min(0),
+  chunkSize: z.number().int().min(1),
+  chunksTotal: z.number().int().min(1),
+  status: ZRBUploadSessionStatus,
+  createdAt: z.date(),
+  expiresAt: z.date(),
+  fileId: z.string().optional(),
+  isPublic: z.boolean().optional(),
+  error: z.string().optional()
+});
+const RBUploadSessionSchema = new Schema$1({
+  _id: {
+    type: String,
+    required: true
+  },
+  userId: {
+    type: String,
+    required: false,
+    index: true
+  },
+  ownerKeyHash: {
+    type: String,
+    required: false
+  },
+  filename: {
+    type: String,
+    required: true
+  },
+  mimeType: {
+    type: String,
+    required: true
+  },
+  totalSize: {
+    type: Number,
+    required: true
+  },
+  chunkSize: {
+    type: Number,
+    required: true
+  },
+  chunksTotal: {
+    type: Number,
+    required: true
+  },
+  status: {
+    type: String,
+    required: true,
+    enum: ZRBUploadSessionStatus.options
+  },
+  createdAt: {
+    type: Date,
+    required: true,
+    default: Date.now
+  },
+  expiresAt: {
+    type: Date,
+    required: true
+  },
+  fileId: {
+    type: String,
+    required: false
+  },
+  isPublic: {
+    type: Boolean,
+    required: false
+  },
+  error: {
+    type: String,
+    required: false
+  }
+}, {
+  versionKey: false
+});
+RBUploadSessionSchema.index({
+  expiresAt: 1
+}, {
+  expireAfterSeconds: 0
+});
+const RBUploadSessionPolicy = {
+  subject: "RBUploadSession",
+  define: (builder, ctx) => {
+    builder.can("create", "RBUploadSession");
+    if (ctx.userId) {
+      builder.can("read", "RBUploadSession", {
+        userId: ctx.userId
+      });
+      builder.can("update", "RBUploadSession", {
+        userId: ctx.userId
+      });
+      builder.can("delete", "RBUploadSession", {
+        userId: ctx.userId
+      });
+    }
+    const uploadKeyHash = typeof ctx.claims?.uploadKeyHash === "string" ? ctx.claims.uploadKeyHash.trim() : "";
+    if (uploadKeyHash) {
+      builder.can("read", "RBUploadSession", {
+        ownerKeyHash: uploadKeyHash
+      });
+      builder.can("update", "RBUploadSession", {
+        ownerKeyHash: uploadKeyHash
+      });
+      builder.can("delete", "RBUploadSession", {
+        ownerKeyHash: uploadKeyHash
+      });
+    }
+  }
+};
+const ZRBUploadChunk = z.object({
+  uploadId: z.string(),
+  index: z.number().int().min(0),
+  data: z.unknown(),
+  size: z.number().int().min(0),
+  sha256: z.string().optional(),
+  createdAt: z.date(),
+  expiresAt: z.date()
+});
+const RBUploadChunkSchema = new Schema$1({
+  uploadId: {
+    type: String,
+    required: true,
+    index: true
+  },
+  index: {
+    type: Number,
+    required: true
+  },
+  data: {
+    type: Buffer,
+    required: true
+  },
+  size: {
+    type: Number,
+    required: true
+  },
+  sha256: {
+    type: String,
+    required: false
+  },
+  createdAt: {
+    type: Date,
+    required: true,
+    default: Date.now
+  },
+  expiresAt: {
+    type: Date,
+    required: true
+  }
+}, {
+  versionKey: false
 });
-var RBUploadSessionSchema = new Schema$1({
-	_id: {
-		type: String,
-		required: true
-	},
-	userId: {
-		type: String,
-		required: false,
-		index: true
-	},
-	ownerKeyHash: {
-		type: String,
-		required: false
-	},
-	filename: {
-		type: String,
-		required: true
-	},
-	mimeType: {
-		type: String,
-		required: true
-	},
-	totalSize: {
-		type: Number,
-		required: true
-	},
-	chunkSize: {
-		type: Number,
-		required: true
-	},
-	chunksTotal: {
-		type: Number,
-		required: true
-	},
-	status: {
-		type: String,
-		required: true,
-		enum: ZRBUploadSessionStatus.options
-	},
-	createdAt: {
-		type: Date,
-		required: true,
-		default: Date.now
-	},
-	expiresAt: {
-		type: Date,
-		required: true
-	},
-	fileId: {
-		type: String,
-		required: false
-	},
-	isPublic: {
-		type: Boolean,
-		required: false
-	},
-	error: {
-		type: String,
-		required: false
-	}
-}, { versionKey: false });
-RBUploadSessionSchema.index({ expiresAt: 1 }, { expireAfterSeconds: 0 });
-var RBUploadSessionPolicy = {
-	subject: "RBUploadSession",
-	define: (builder, ctx) => {
-		builder.can("create", "RBUploadSession");
-		if (ctx.userId) {
-			builder.can("read", "RBUploadSession", { userId: ctx.userId });
-			builder.can("update", "RBUploadSession", { userId: ctx.userId });
-			builder.can("delete", "RBUploadSession", { userId: ctx.userId });
-		}
-		const uploadKeyHash = typeof ctx.claims?.uploadKeyHash === "string" ? ctx.claims.uploadKeyHash.trim() : "";
-		if (uploadKeyHash) {
-			builder.can("read", "RBUploadSession", { ownerKeyHash: uploadKeyHash });
-			builder.can("update", "RBUploadSession", { ownerKeyHash: uploadKeyHash });
-			builder.can("delete", "RBUploadSession", { ownerKeyHash: uploadKeyHash });
-		}
-	}
-};
-//#endregion
-//#region src/models/RBUploadChunk.ts
-var ZRBUploadChunk = z$1.object({
-	uploadId: z$1.string(),
-	index: z$1.number().int().min(0),
-	data: z$1.unknown(),
-	size: z$1.number().int().min(0),
-	sha256: z$1.string().optional(),
-	createdAt: z$1.date(),
-	expiresAt: z$1.date()
+RBUploadChunkSchema.index({
+  uploadId: 1,
+  index: 1
+}, {
+  unique: true
 });
-var RBUploadChunkSchema = new Schema$1({
-	uploadId: {
-		type: String,
-		required: true,
-		index: true
-	},
-	index: {
-		type: Number,
-		required: true
-	},
-	data: {
-		type: Buffer,
-		required: true
-	},
-	size: {
-		type: Number,
-		required: true
-	},
-	sha256: {
-		type: String,
-		required: false
-	},
-	createdAt: {
-		type: Date,
-		required: true,
-		default: Date.now
-	},
-	expiresAt: {
-		type: Date,
-		required: true
-	}
-}, { versionKey: false });
 RBUploadChunkSchema.index({
-	uploadId: 1,
-	index: 1
-}, { unique: true });
-RBUploadChunkSchema.index({ expiresAt: 1 }, { expireAfterSeconds: 0 });
-//#endregion
-//#region src/models/RBNotification.ts
-var ZRBNotification = z$1.object({
-	userId: z$1.string(),
-	topic: z$1.string().optional(),
-	title: z$1.string(),
-	body: z$1.string().optional(),
-	url: z$1.string().optional(),
-	createdAt: z$1.date(),
-	seenAt: z$1.date().optional(),
-	readAt: z$1.date().optional(),
-	archivedAt: z$1.date().optional(),
-	metadata: z$1.record(z$1.string(), z$1.unknown()).optional()
+  expiresAt: 1
+}, {
+  expireAfterSeconds: 0
+});
+const ZRBNotification = z.object({
+  userId: z.string(),
+  topic: z.string().optional(),
+  title: z.string(),
+  body: z.string().optional(),
+  url: z.string().optional(),
+  createdAt: z.date(),
+  seenAt: z.date().optional(),
+  readAt: z.date().optional(),
+  archivedAt: z.date().optional(),
+  metadata: z.record(z.string(), z.unknown()).optional()
+});
+const TTL_90_DAYS_S = 60 * 60 * 24 * 90;
+const RBNotificationSchema = new Schema$1({
+  userId: {
+    type: String,
+    required: true,
+    index: true
+  },
+  topic: {
+    type: String,
+    required: false,
+    index: true
+  },
+  title: {
+    type: String,
+    required: true
+  },
+  body: {
+    type: String,
+    required: false
+  },
+  url: {
+    type: String,
+    required: false
+  },
+  createdAt: {
+    type: Date,
+    required: true,
+    default: Date.now,
+    index: true
+  },
+  seenAt: {
+    type: Date,
+    required: false,
+    index: true
+  },
+  readAt: {
+    type: Date,
+    required: false,
+    index: true
+  },
+  archivedAt: {
+    type: Date,
+    required: false
+  },
+  metadata: {
+    type: Schema$1.Types.Mixed,
+    required: false
+  }
+}, {
+  versionKey: false
 });
-var TTL_90_DAYS_S = 3600 * 24 * 90;
-var RBNotificationSchema = new Schema$1({
-	userId: {
-		type: String,
-		required: true,
-		index: true
-	},
-	topic: {
-		type: String,
-		required: false,
-		index: true
-	},
-	title: {
-		type: String,
-		required: true
-	},
-	body: {
-		type: String,
-		required: false
-	},
-	url: {
-		type: String,
-		required: false
-	},
-	createdAt: {
-		type: Date,
-		required: true,
-		default: Date.now,
-		index: true
-	},
-	seenAt: {
-		type: Date,
-		required: false,
-		index: true
-	},
-	readAt: {
-		type: Date,
-		required: false,
-		index: true
-	},
-	archivedAt: {
-		type: Date,
-		required: false
-	},
-	metadata: {
-		type: Schema$1.Types.Mixed,
-		required: false
-	}
-}, { versionKey: false });
 RBNotificationSchema.index({
-	userId: 1,
-	archivedAt: 1,
-	createdAt: -1
+  userId: 1,
+  archivedAt: 1,
+  createdAt: -1
 });
 RBNotificationSchema.index({
-	userId: 1,
-	seenAt: 1,
-	archivedAt: 1,
-	createdAt: -1
+  userId: 1,
+  seenAt: 1,
+  archivedAt: 1,
+  createdAt: -1
 });
 RBNotificationSchema.index({
-	userId: 1,
-	readAt: 1,
-	archivedAt: 1,
-	createdAt: -1
+  userId: 1,
+  readAt: 1,
+  archivedAt: 1,
+  createdAt: -1
 });
-RBNotificationSchema.index({ archivedAt: 1 }, { expireAfterSeconds: TTL_90_DAYS_S });
-var RBNotificationPolicy = {
-	subject: "RBNotification",
-	define: (builder, ctx) => {
-		if (!ctx.userId) return;
-		builder.can("create", "RBNotification");
-		builder.can("read", "RBNotification", { userId: ctx.userId });
-		builder.can("update", "RBNotification", { userId: ctx.userId });
-		builder.can("delete", "RBNotification", { userId: ctx.userId });
-	}
-};
-//#endregion
-//#region src/models/RBNotificationSettings.ts
-var ZRBNotificationDigestFrequency = z$1.enum([
-	"off",
-	"daily",
-	"weekly"
-]);
-var ZRBNotificationTopicPreference = z$1.object({
-	topic: z$1.string(),
-	inApp: z$1.boolean(),
-	emailDigest: z$1.boolean(),
-	push: z$1.boolean()
+RBNotificationSchema.index({
+  archivedAt: 1
+}, {
+  expireAfterSeconds: TTL_90_DAYS_S
 });
-var ZRBNotificationSettings = z$1.object({
-	userId: z$1.string(),
-	digestFrequency: ZRBNotificationDigestFrequency,
-	topicPreferences: z$1.array(ZRBNotificationTopicPreference).optional(),
-	lastDigestSentAt: z$1.date().optional()
+const RBNotificationPolicy = {
+  subject: "RBNotification",
+  define: (builder, ctx) => {
+    if (!ctx.userId) return;
+    builder.can("create", "RBNotification");
+    builder.can("read", "RBNotification", {
+      userId: ctx.userId
+    });
+    builder.can("update", "RBNotification", {
+      userId: ctx.userId
+    });
+    builder.can("delete", "RBNotification", {
+      userId: ctx.userId
+    });
+  }
+};
+const ZRBNotificationDigestFrequency = z.enum(["off", "daily", "weekly"]);
+const ZRBNotificationTopicPreference = z.object({
+  topic: z.string(),
+  inApp: z.boolean(),
+  emailDigest: z.boolean(),
+  push: z.boolean()
 });
-var TopicPreferenceSchema = new Schema$1({
-	topic: {
-		type: String,
-		required: true
-	},
-	inApp: {
-		type: Boolean,
-		required: true,
-		default: true
-	},
-	emailDigest: {
-		type: Boolean,
-		required: true,
-		default: true
-	},
-	push: {
-		type: Boolean,
-		required: true,
-		default: false
-	}
-}, { _id: false });
-var RBNotificationSettingsSchema = new Schema$1({
-	userId: {
-		type: String,
-		required: true
-	},
-	digestFrequency: {
-		type: String,
-		required: true,
-		enum: ZRBNotificationDigestFrequency.options,
-		default: "weekly"
-	},
-	topicPreferences: {
-		type: [TopicPreferenceSchema],
-		default: []
-	},
-	lastDigestSentAt: {
-		type: Date,
-		required: false
-	}
+const ZRBNotificationSettings = z.object({
+  userId: z.string(),
+  digestFrequency: ZRBNotificationDigestFrequency,
+  topicPreferences: z.array(ZRBNotificationTopicPreference).optional(),
+  lastDigestSentAt: z.date().optional()
+});
+const TopicPreferenceSchema = new Schema$1({
+  topic: {
+    type: String,
+    required: true
+  },
+  inApp: {
+    type: Boolean,
+    required: true,
+    default: true
+  },
+  emailDigest: {
+    type: Boolean,
+    required: true,
+    default: true
+  },
+  push: {
+    type: Boolean,
+    required: true,
+    default: false
+  }
 }, {
-	versionKey: false,
-	timestamps: true
+  _id: false
+});
+const RBNotificationSettingsSchema = new Schema$1({
+  userId: {
+    type: String,
+    required: true
+  },
+  digestFrequency: {
+    type: String,
+    required: true,
+    enum: ZRBNotificationDigestFrequency.options,
+    default: "weekly"
+  },
+  topicPreferences: {
+    type: [TopicPreferenceSchema],
+    default: []
+  },
+  lastDigestSentAt: {
+    type: Date,
+    required: false
+  }
+}, {
+  versionKey: false,
+  timestamps: true
 });
-RBNotificationSettingsSchema.index({ userId: 1 }, { unique: true });
 RBNotificationSettingsSchema.index({
-	userId: 1,
-	"topicPreferences.topic": 1
+  userId: 1
+}, {
+  unique: true
 });
-var RBNotificationSettingsPolicy = {
-	subject: "RBNotificationSettings",
-	define: (builder, ctx) => {
-		if (!ctx.userId) return;
-		builder.can("create", "RBNotificationSettings");
-		builder.can("read", "RBNotificationSettings", { userId: ctx.userId });
-		builder.can("update", "RBNotificationSettings", { userId: ctx.userId });
-	}
-};
-//#endregion
-//#region src/models/RBOAuthRequest.ts
-var ZRBOAuthRequest = z$1.object({
-	_id: z$1.string(),
-	providerId: z$1.string(),
-	codeVerifier: z$1.string(),
-	returnTo: z$1.string().optional(),
-	createdAt: z$1.date(),
-	expiresAt: z$1.date()
+RBNotificationSettingsSchema.index({
+  userId: 1,
+  "topicPreferences.topic": 1
 });
-var RBOAuthRequestSchema = new Schema$1({
-	_id: {
-		type: String,
-		required: true
-	},
-	providerId: {
-		type: String,
-		required: true,
-		index: true
-	},
-	codeVerifier: {
-		type: String,
-		required: true
-	},
-	returnTo: {
-		type: String,
-		required: false
-	},
-	createdAt: {
-		type: Date,
-		required: true,
-		default: Date.now
-	},
-	expiresAt: {
-		type: Date,
-		required: true
-	}
-}, { versionKey: false });
-RBOAuthRequestSchema.index({ expiresAt: 1 }, { expireAfterSeconds: 0 });
-//#endregion
-//#region src/models/index.ts
-var models_exports = /* @__PURE__ */ __exportAll({
-	RBNotificationPolicy: () => RBNotificationPolicy,
-	RBNotificationSchema: () => RBNotificationSchema,
-	RBNotificationSettingsPolicy: () => RBNotificationSettingsPolicy,
-	RBNotificationSettingsSchema: () => RBNotificationSettingsSchema,
-	RBOAuthRequestSchema: () => RBOAuthRequestSchema,
-	RBRtsChangeSchema: () => RBRtsChangeSchema,
-	RBRtsCounterSchema: () => RBRtsCounterSchema,
-	RBTenantSchema: () => RBTenantSchema,
-	RBTenantSubscriptionEventSchema: () => RBTenantSubscriptionEventSchema,
-	RBTenantSubscriptionSchema: () => RBTenantSubscriptionSchema,
-	RBUploadChunkSchema: () => RBUploadChunkSchema,
-	RBUploadSessionPolicy: () => RBUploadSessionPolicy,
-	RBUploadSessionSchema: () => RBUploadSessionSchema,
-	RBUserSchema: () => RBUserSchema,
-	ZRBNotification: () => ZRBNotification,
-	ZRBNotificationDigestFrequency: () => ZRBNotificationDigestFrequency,
-	ZRBNotificationSettings: () => ZRBNotificationSettings,
-	ZRBNotificationTopicPreference: () => ZRBNotificationTopicPreference,
-	ZRBOAuthRequest: () => ZRBOAuthRequest,
-	ZRBRtsChange: () => ZRBRtsChange,
-	ZRBRtsChangeOp: () => ZRBRtsChangeOp,
-	ZRBRtsCounter: () => ZRBRtsCounter,
-	ZRBTenant: () => ZRBTenant,
-	ZRBTenantSubscription: () => ZRBTenantSubscription,
-	ZRBTenantSubscriptionChangeDirection: () => ZRBTenantSubscriptionChangeDirection,
-	ZRBTenantSubscriptionEvent: () => ZRBTenantSubscriptionEvent,
-	ZRBTenantSubscriptionEventSource: () => ZRBTenantSubscriptionEventSource,
-	ZRBTenantSubscriptionIntervalUnit: () => ZRBTenantSubscriptionIntervalUnit,
-	ZRBTenantSubscriptionScope: () => ZRBTenantSubscriptionScope,
-	ZRBTenantSubscriptionStatus: () => ZRBTenantSubscriptionStatus,
-	ZRBTenantSubscriptionType: () => ZRBTenantSubscriptionType,
-	ZRBUploadChunk: () => ZRBUploadChunk,
-	ZRBUploadSession: () => ZRBUploadSession,
-	ZRBUploadSessionStatus: () => ZRBUploadSessionStatus,
-	ZRBUser: () => ZRBUser
+const RBNotificationSettingsPolicy = {
+  subject: "RBNotificationSettings",
+  define: (builder, ctx) => {
+    if (!ctx.userId) return;
+    builder.can("create", "RBNotificationSettings");
+    builder.can("read", "RBNotificationSettings", {
+      userId: ctx.userId
+    });
+    builder.can("update", "RBNotificationSettings", {
+      userId: ctx.userId
+    });
+  }
+};
+const ZRBOAuthRequest = z.object({
+  _id: z.string(),
+  providerId: z.string(),
+  codeVerifier: z.string(),
+  returnTo: z.string().optional(),
+  createdAt: z.date(),
+  expiresAt: z.date()
+});
+const RBOAuthRequestSchema = new Schema$1({
+  _id: {
+    type: String,
+    required: true
+  },
+  providerId: {
+    type: String,
+    required: true,
+    index: true
+  },
+  codeVerifier: {
+    type: String,
+    required: true
+  },
+  returnTo: {
+    type: String,
+    required: false
+  },
+  createdAt: {
+    type: Date,
+    required: true,
+    default: Date.now
+  },
+  expiresAt: {
+    type: Date,
+    required: true
+  }
+}, {
+  versionKey: false
 });
-//#endregion
-//#region src/mongoose/extendMongooseSchema.ts
+RBOAuthRequestSchema.index({
+  expiresAt: 1
+}, {
+  expireAfterSeconds: 0
+});
+const frameworkSchemas = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  RBNotificationPolicy,
+  RBNotificationSchema,
+  RBNotificationSettingsPolicy,
+  RBNotificationSettingsSchema,
+  RBOAuthRequestSchema,
+  RBRtsChangeSchema,
+  RBRtsCounterSchema,
+  RBTenantSchema,
+  RBTenantSubscriptionEventSchema,
+  RBTenantSubscriptionSchema,
+  RBUploadChunkSchema,
+  RBUploadSessionPolicy,
+  RBUploadSessionSchema,
+  RBUserSchema,
+  ZRBNotification,
+  ZRBNotificationDigestFrequency,
+  ZRBNotificationSettings,
+  ZRBNotificationTopicPreference,
+  ZRBOAuthRequest,
+  ZRBRtsChange,
+  ZRBRtsChangeOp,
+  ZRBRtsCounter,
+  ZRBTenant,
+  ZRBTenantSubscription,
+  ZRBTenantSubscriptionChangeDirection,
+  ZRBTenantSubscriptionEvent,
+  ZRBTenantSubscriptionEventSource,
+  ZRBTenantSubscriptionIntervalUnit,
+  ZRBTenantSubscriptionScope,
+  ZRBTenantSubscriptionStatus,
+  ZRBTenantSubscriptionType,
+  ZRBUploadChunk,
+  ZRBUploadSession,
+  ZRBUploadSessionStatus,
+  ZRBUser
+}, Symbol.toStringTag, { value: "Module" }));
 function extendMongooseSchema(baseSchema, ...extensions) {
-	const schema = baseSchema.clone();
-	extensions.forEach((extension) => schema.add(extension));
-	return schema;
+  const schema = baseSchema.clone();
+  extensions.forEach((extension) => schema.add(extension));
+  return schema;
 }
 function omitMongooseSchemaPaths(schema, paths) {
-	const clone = schema.clone();
-	paths.forEach((path) => clone.remove(path));
-	return clone;
+  const clone = schema.clone();
+  paths.forEach((path) => clone.remove(path));
+  return clone;
 }
-//#endregion
-//#region src/mongoose/localizedStringField.ts
 function localizedStringField(options) {
-	const userGet = options?.get;
-	return {
-		...options,
-		type: Schema$1.Types.Mixed,
-		get: (value) => withLocalizedStringFallback(userGet ? userGet(value) : value)
-	};
+  const userGet = options?.get;
+  return {
+    ...options,
+    type: Schema$1.Types.Mixed,
+    get: (value) => withLocalizedStringFallback(userGet ? userGet(value) : value)
+  };
 }
-//#endregion
-//#region src/mongoose/index.ts
-var { Schema, model } = mongoose;
-//#endregion
-//#region src/pagination/errors.ts
-var PaginationValidationError = class extends Error {
-	code = "invalid_pagination";
-	statusCode = 400;
-	constructor(message, options) {
-		super(message, options);
-		this.name = "PaginationValidationError";
-	}
-};
-var isPaginationValidationError = (error) => {
-	if (!error || typeof error !== "object") return false;
-	const anyError = error;
-	return anyError.name === "PaginationValidationError" && anyError.code === "invalid_pagination" && anyError.statusCode === 400;
-};
-//#endregion
-//#region src/pagination/normalizeSpec.ts
-var DISALLOWED_MONGO_FIELD_SEGMENTS = new Set([
-	"__proto__",
-	"constructor",
-	"prototype"
-]);
-var PAGINATION_LIMIT_MAX = 128;
-var normalizePaginationSpec = (spec) => {
-	if (!spec || typeof spec !== "object") throw new PaginationValidationError("Invalid PaginationSpec");
-	const limit = normalizeLimit(spec.limit);
-	const direction = spec.direction ?? "next";
-	if (direction !== "next" && direction !== "prev") throw new PaginationValidationError("Invalid pagination direction");
-	if (!Array.isArray(spec.sort) || spec.sort.length === 0) throw new PaginationValidationError("Invalid pagination sort");
-	const sort = spec.sort.map(({ field, order }) => ({
-		field: assertSafeMongoFieldPath(field),
-		order: normalizeOrder(order)
-	}));
-	const seenFields = /* @__PURE__ */ new Set();
-	for (const { field } of sort) {
-		if (seenFields.has(field)) throw new PaginationValidationError(`Duplicate pagination sort field: ${field}`);
-		seenFields.add(field);
-	}
-	const primaryOrder = sort[0]?.order;
-	if (!seenFields.has("_id")) sort.push({
-		field: "_id",
-		order: primaryOrder
-	});
-	return {
-		...spec,
-		limit,
-		direction,
-		sort
-	};
-};
-var normalizeLimit = (limit) => {
-	if (typeof limit !== "number" || !Number.isFinite(limit) || !Number.isInteger(limit) || limit <= 0) throw new PaginationValidationError("Invalid pagination limit");
-	if (limit > PAGINATION_LIMIT_MAX) throw new PaginationValidationError("Invalid pagination limit");
-	return limit;
-};
-var normalizeOrder = (order) => {
-	if (order !== "asc" && order !== "desc") throw new PaginationValidationError("Invalid pagination order");
-	return order;
-};
-var assertSafeMongoFieldPath = (field) => {
-	if (typeof field !== "string" || field.length === 0) throw new PaginationValidationError("Invalid pagination sort field");
-	if (field.startsWith("$")) throw new PaginationValidationError("Invalid pagination sort field");
-	const parts = field.split(".");
-	for (const part of parts) {
-		if (part.length === 0) throw new PaginationValidationError("Invalid pagination sort field");
-		if (DISALLOWED_MONGO_FIELD_SEGMENTS.has(part)) throw new PaginationValidationError("Invalid pagination sort field");
-		if (!/^[a-zA-Z0-9_]+$/.test(part)) throw new PaginationValidationError("Invalid pagination sort field");
-	}
-	return field;
-};
-//#endregion
-//#region src/pagination/cursor.ts
-var encodePaginationCursor = (spec, node, options) => {
-	const normalized = normalizePaginationSpec(spec);
-	const values = Object.create(null);
-	for (const { field } of normalized.sort) {
-		const value = readFieldValue(node, field);
-		if (typeof value === "undefined") throw new Error(`Pagination cursor encode failed (missing field: ${field})`);
-		values[field] = encodeCursorValue(field, value);
-	}
-	const payload = {
-		v: 1,
-		values
-	};
-	const payloadB64 = Buffer.from(JSON.stringify(payload), "utf8").toString("base64url");
-	return `${payloadB64}.${signCursorPayloadB64(payloadB64, options.signingSecret)}`;
-};
-var decodePaginationCursor = (spec, cursor, options) => {
-	const normalized = normalizePaginationSpec(spec);
-	const [payloadB64, sigB64, ...rest] = cursor.split(".");
-	if (rest.length > 0) throw new PaginationValidationError("Invalid pagination cursor format");
-	if (!sigB64) throw new PaginationValidationError("Invalid pagination cursor format");
-	verifyCursorSignature(payloadB64, sigB64, options.signingSecret);
-	const payloadRaw = Buffer.from(payloadB64, "base64url").toString("utf8");
-	let payloadUnknown;
-	try {
-		payloadUnknown = JSON.parse(payloadRaw);
-	} catch {
-		throw new PaginationValidationError("Invalid pagination cursor payload");
-	}
-	if (!payloadUnknown || typeof payloadUnknown !== "object") throw new PaginationValidationError("Invalid pagination cursor payload");
-	const payload = payloadUnknown;
-	if (payload.v !== 1) throw new PaginationValidationError("Unsupported pagination cursor version");
-	if (!payload.values || typeof payload.values !== "object") throw new PaginationValidationError("Invalid pagination cursor payload");
-	const decoded = Object.create(null);
-	for (const { field } of normalized.sort) {
-		if (!Object.prototype.hasOwnProperty.call(payload.values, field)) throw new PaginationValidationError(`Pagination cursor missing field: ${field}`);
-		const encodedValue = payload.values[field];
-		decoded[field] = decodeCursorValue(field, encodedValue);
-	}
-	return decoded;
-};
-var signCursorPayloadB64 = (payloadB64, secret) => {
-	return createHmac("sha256", secret).update(payloadB64, "utf8").digest("base64url");
-};
-var verifyCursorSignature = (payloadB64, sigB64, secret) => {
-	const expectedSigB64 = signCursorPayloadB64(payloadB64, secret);
-	const a = Buffer.from(sigB64, "utf8");
-	const b = Buffer.from(expectedSigB64, "utf8");
-	if (a.length !== b.length || !timingSafeEqual(a, b)) throw new PaginationValidationError("Invalid pagination cursor signature");
-};
-var unwrapCursorComparableValue = (value) => {
-	if (value === null || typeof value !== "object") return value;
-	if (value instanceof Date || value instanceof Types.ObjectId) return value;
-	let current = value;
-	for (let depth = 0; depth < 4; depth += 1) {
-		if (!current || typeof current !== "object") return current;
-		if (current instanceof Date || current instanceof Types.ObjectId) return current;
-		if (!("_id" in current)) return current;
-		current = current._id;
-	}
-	return current;
-};
-var encodeCursorValue = (field, value) => {
-	const comparableValue = unwrapCursorComparableValue(value);
-	if (comparableValue === null) return null;
-	if (field === "_id") {
-		if (comparableValue instanceof Types.ObjectId) return { $oid: comparableValue.toHexString() };
-		if (typeof comparableValue === "string") return comparableValue;
-		throw new Error("Pagination cursor encode failed (_id must be an ObjectId or string)");
-	}
-	if (comparableValue instanceof Date) return { $date: comparableValue.toISOString() };
-	if (typeof comparableValue === "string" || typeof comparableValue === "number" || typeof comparableValue === "boolean") return comparableValue;
-	if (comparableValue instanceof Types.ObjectId) return { $oid: comparableValue.toHexString() };
-	throw new Error(`Unsupported pagination cursor value type for field: ${field}`);
-};
-var decodeCursorValue = (field, value) => {
-	if (value === null) return null;
-	if (typeof value === "string") return value;
-	if (typeof value === "number" || typeof value === "boolean") return value;
-	if (!value || typeof value !== "object") throw new PaginationValidationError(`Invalid pagination cursor value for field: ${field}`);
-	if ("$date" in value) {
-		if (typeof value.$date !== "string") throw new PaginationValidationError(`Invalid pagination cursor date for field: ${field}`);
-		const d = new Date(value.$date);
-		if (Number.isNaN(d.getTime())) throw new PaginationValidationError(`Invalid pagination cursor date for field: ${field}`);
-		return d;
-	}
-	if ("$oid" in value) {
-		if (typeof value.$oid !== "string" || !Types.ObjectId.isValid(value.$oid)) throw new PaginationValidationError(`Invalid pagination cursor ObjectId for field: ${field}`);
-		return new Types.ObjectId(value.$oid);
-	}
-	throw new PaginationValidationError(`Invalid pagination cursor value for field: ${field}`);
-};
-var readFieldValue = (node, field) => {
-	if (!node || typeof node !== "object") return void 0;
-	if ("get" in node && typeof node.get === "function") return node.get(field);
-	return field.split(".").reduce((acc, key) => {
-		if (!acc || typeof acc !== "object") return void 0;
-		return acc[key];
-	}, node);
-};
-//#endregion
-//#region src/pagination/compileMongoPagination.ts
-var compileMongoPagination = (spec, options) => {
-	const normalized = normalizePaginationSpec(spec);
-	const mongoLimit = normalized.limit + 1;
-	const mongoSort = toMongoSort(normalized);
-	if (normalized.cursor == null) return {
-		spec: normalized,
-		mongoFilterDelta: {},
-		mongoSort,
-		mongoLimit
-	};
-	if (typeof normalized.cursor !== "string" || normalized.cursor.length === 0) throw new PaginationValidationError("Invalid pagination cursor");
-	return {
-		spec: normalized,
-		mongoFilterDelta: buildKeysetFilterDelta(normalized, decodePaginationCursor(normalized, normalized.cursor, options.cursor)),
-		mongoSort,
-		mongoLimit
-	};
-};
-var toMongoSort = (spec) => {
-	const mongoSort = Object.create(null);
-	for (const { field, order } of spec.sort) mongoSort[field] = (spec.direction === "prev" ? invertOrder(order) : order) === "asc" ? 1 : -1;
-	return mongoSort;
-};
-var buildKeysetFilterDelta = (spec, cursorValues) => {
-	const branches = [];
-	for (let i = 0; i < spec.sort.length; i++) {
-		const current = spec.sort[i];
-		if (!current) continue;
-		const and = [];
-		for (let j = 0; j < i; j++) {
-			const prev = spec.sort[j];
-			if (!prev) continue;
-			const eq = Object.create(null);
-			eq[prev.field] = cursorValues[prev.field];
-			and.push(eq);
-		}
-		const op = getKeysetOp(current.order, spec.direction);
-		const cmpOp = Object.create(null);
-		cmpOp[op] = cursorValues[current.field];
-		const cmp = Object.create(null);
-		cmp[current.field] = cmpOp;
-		and.push(cmp);
-		branches.push(and.length === 1 ? and[0] : { $and: and });
-	}
-	return { $or: branches };
-};
-var getKeysetOp = (order, direction) => {
-	if (direction === "next") return order === "asc" ? "$gt" : "$lt";
-	return order === "asc" ? "$lt" : "$gt";
-};
-var invertOrder = (order) => {
-	return order === "asc" ? "desc" : "asc";
-};
-//#endregion
-//#region src/pagination/materializePagination.ts
-var materializeMongoPagination = (compiled, fetchedNodes, options) => {
-	const limit = compiled.spec.limit;
-	const hasMore = fetchedNodes.length > limit;
-	const trimmed = fetchedNodes.slice(0, limit);
-	const nodes = compiled.spec.direction === "prev" ? trimmed.reverse() : trimmed;
-	const hasPrevPage = compiled.spec.direction === "next" ? Boolean(compiled.spec.cursor) : hasMore;
-	const hasNextPage = compiled.spec.direction === "next" ? hasMore : Boolean(compiled.spec.cursor);
-	const pageInfo = {
-		hasNextPage,
-		hasPrevPage
-	};
-	if (nodes.length === 0) return {
-		nodes,
-		pageInfo
-	};
-	if (hasPrevPage) pageInfo.prevCursor = encodePaginationCursor(compiled.spec, nodes[0], options.cursor);
-	if (hasNextPage) pageInfo.nextCursor = encodePaginationCursor(compiled.spec, nodes[nodes.length - 1], options.cursor);
-	return {
-		nodes,
-		pageInfo
-	};
-};
-//#endregion
-//#region src/pagination/mongoAdapter.ts
-var MongoAdapter = { applyPagination: (query, compiled) => {
-	query.where(compiled.mongoFilterDelta);
-	query.sort(compiled.mongoSort);
-	query.limit(compiled.mongoLimit);
-	return query;
-} };
-//#endregion
-//#region src/pagination/paginateMongoQuery.ts
-var paginateMongoQuery = async (query, pagination, options) => {
-	const compiled = compileMongoPagination(pagination, { cursor: options.cursor });
-	MongoAdapter.applyPagination(query, compiled);
-	const fetchedNodes = await query.exec();
-	if (!Array.isArray(fetchedNodes)) throw new Error("paginateMongoQuery expects query.exec() to return an array");
-	return materializeMongoPagination(compiled, fetchedNodes, { cursor: options.cursor });
-};
-//#endregion
-//#region src/pagination/mongoPaginationPlugin.ts
-var getQueryOptions$1 = (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;
-};
-var getCursorFromOptions = (query) => {
-	return getQueryOptions$1(query)?.paginationCursor;
-};
-var mongoPaginationPlugin = (schema, pluginOptions) => {
-	schema.query.paginate = async function(pagination, options) {
-		const spec = pagination ?? getPaginationFromOptions(this);
-		if (!spec) throw new Error("Missing pagination spec");
-		const cursor = options?.cursor ?? getCursorFromOptions(this) ?? pluginOptions?.cursor;
-		if (!cursor?.signingSecret) throw new Error("Missing pagination cursor signingSecret");
-		return await paginateMongoQuery(this, spec, { cursor });
-	};
-};
-//#endregion
-//#region src/search/index.ts
-var buildSearchTextStage = (options) => {
-	const index = options.index.trim();
-	if (!index) throw new Error("Missing search index name");
-	const query = options.query.trim();
-	if (!query) throw new Error("Missing search query");
-	const stage = { $search: {
-		index,
-		text: {
-			query,
-			path: options.path
-		}
-	} };
-	if (options.highlightPath) stage.$search.highlight = { path: options.highlightPath };
-	return stage;
-};
-var searchMetaProjection = () => {
-	return {
-		score: { $meta: "searchScore" },
-		highlights: { $meta: "searchHighlights" }
-	};
-};
-var listResultHasIndex = (listResult, name) => {
-	if (!listResult || typeof listResult !== "object") return false;
-	if (!("cursor" in listResult)) return false;
-	const cursor = listResult.cursor;
-	if (!cursor || typeof cursor !== "object") return false;
-	const firstBatch = cursor.firstBatch;
-	if (!Array.isArray(firstBatch)) return false;
-	return firstBatch.some((idx) => idx && typeof idx === "object" && "name" in idx && idx.name === name);
-};
-var isIndexAlreadyExistsError = (error) => {
-	if (!error || typeof error !== "object") return false;
-	if (("codeName" in error ? error.codeName : void 0) === "IndexAlreadyExists") return true;
-	const message = "message" in error ? String(error.message ?? "") : "";
-	return /already exists/i.test(message);
-};
-var ensureSearchIndex = async (params) => {
-	const collection = params.collection.trim();
-	if (!collection) throw new Error("Missing collection name");
-	const name = params.name.trim();
-	if (!name) throw new Error("Missing search index name");
-	let listResult;
-	try {
-		listResult = await params.db.command({ listSearchIndexes: collection });
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		throw new Error(`listSearchIndexes failed for "${collection}": ${message}`);
-	}
-	if (listResultHasIndex(listResult, name)) return { created: false };
-	try {
-		await params.db.command({
-			createSearchIndexes: collection,
-			indexes: [{
-				name,
-				definition: params.definition
-			}]
-		});
-	} catch (error) {
-		if (isIndexAlreadyExistsError(error)) return { created: false };
-		const message = error instanceof Error ? error.message : String(error);
-		throw new Error(`createSearchIndexes failed for "${collection}" (index "${name}"): ${message}`);
-	}
-	return { created: true };
-};
-//#endregion
-//#region src/dbNames.ts
-var getAppName$1 = (env = process.env) => {
-	const appName = env.APP_NAME?.trim();
-	if (!appName) throw new Error("Missing APP_NAME");
-	return appName;
-};
-var GLOBAL_DB_SUFFIX = "-global-db";
-var getGlobalDbName = (env = process.env) => {
-	return `${getAppName$1(env)}${GLOBAL_DB_SUFFIX}`;
-};
-var getTenantDbName = (tenantId, env = process.env) => {
-	return `${getAppName$1(env)}-${tenantId.trim()}-db`;
-};
-//#endregion
-//#region src/getMongoUrl.ts
-var getMongoUrl = (env = process.env) => {
-	const explicitUrl = env.MONGODB_URL ?? env.MONGO_URL ?? env.MONGODB_URI ?? env.DB_URL;
-	if (explicitUrl && explicitUrl.trim()) return explicitUrl.trim();
-	const port = env.DB_PORT?.trim();
-	if (!port) throw new Error("Missing Mongo connection details (MONGODB_URL/MONGO_URL/MONGODB_URI/DB_URL/DB_PORT)");
-	return `mongodb://${env.DB_HOST?.trim() || "localhost"}:${port}`;
-};
-//#endregion
-//#region src/ensureMongooseConnection.ts
-var connections = /* @__PURE__ */ new Map();
-var rootConnection = null;
-var CONNECTION_MAX_LISTENERS = 50;
-var waitForOpen = async (connection) => {
-	if (connection.readyState === 1) return;
-	if (connection.getMaxListeners() < CONNECTION_MAX_LISTENERS) connection.setMaxListeners(CONNECTION_MAX_LISTENERS);
-	await new Promise((resolve, reject) => {
-		connection.once("open", resolve);
-		connection.once("error", reject);
-	});
-};
-var ensureMongooseConnection = async (dbName) => {
-	const normalizedDbName = dbName.trim();
-	if (!normalizedDbName) throw new Error("Missing dbName");
-	const existing = connections.get(normalizedDbName);
-	if (existing) {
-		await waitForOpen(existing);
-		return existing;
-	}
-	if (!rootConnection) {
-		const mongoUrl = getMongoUrl();
-		rootConnection = mongoose$1.createConnection(mongoUrl, {
-			sanitizeFilter: true,
-			dbName: normalizedDbName
-		});
-	}
-	await waitForOpen(rootConnection);
-	const connection = rootConnection.name === normalizedDbName ? rootConnection : rootConnection.useDb(normalizedDbName, { useCache: true });
-	await waitForOpen(connection);
-	connections.set(normalizedDbName, connection);
-	return connection;
-};
-//#endregion
-//#region src/rtsChangeLogPlugin.ts
-var RTS_COUNTER_ID = "rts";
-var EXCLUDED_MODEL_NAMES = new Set(["RBRtsChange", "RBRtsCounter"]);
-var maxDeleteIdsRaw = process.env.RB_RTS_DELETE_LOG_MAX_IDS ?? "";
-var maxDeleteIds = Number.isFinite(Number(maxDeleteIdsRaw)) ? Math.max(1, Math.floor(Number(maxDeleteIdsRaw))) : 5e3;
-var deleteMetaByQuery = /* @__PURE__ */ new WeakMap();
-var hasToString = (value) => {
-	if (typeof value !== "object" || value === null) return false;
-	return typeof value.toString === "function";
-};
-var normalizeId = (id) => {
-	if (!id) return null;
-	if (typeof id === "string") return id;
-	if (hasToString(id)) return id.toString();
-	return null;
-};
-var getDbName = (db) => {
-	if (!db || typeof db !== "object") return "";
-	const maybe = db;
-	const raw = maybe.name ?? maybe.db?.databaseName;
-	return typeof raw === "string" ? raw : "";
-};
-var isGlobalDb = (db) => getDbName(db).endsWith(GLOBAL_DB_SUFFIX);
-var getQuerySession = (query) => {
-	const opts = typeof query.getOptions === "function" ? query.getOptions() : void 0;
-	if (!opts || typeof opts !== "object") return void 0;
-	const session = opts.session;
-	if (!session || typeof session !== "object") return void 0;
-	return session;
-};
-var getRtsModels = (db) => {
-	return {
-		RtsCounter: db.models.RBRtsCounter ?? db.model("RBRtsCounter", RBRtsCounterSchema),
-		RtsChange: db.models.RBRtsChange ?? db.model("RBRtsChange", RBRtsChangeSchema)
-	};
-};
-var allocateSeqRange = async (db, count, session) => {
-	const { RtsCounter } = getRtsModels(db);
-	const updated = await RtsCounter.findOneAndUpdate({ _id: RTS_COUNTER_ID }, { $inc: { seq: count } }, {
-		upsert: true,
-		returnDocument: "after",
-		setDefaultsOnInsert: true,
-		projection: { seq: 1 },
-		session
-	}).lean();
-	const end = Number(updated?.seq ?? 0);
-	return {
-		start: end - count + 1,
-		end
-	};
-};
-var insertChanges = async (db, changes, session) => {
-	if (!changes.length) return;
-	const { RtsChange } = getRtsModels(db);
-	const ts = /* @__PURE__ */ new Date();
-	const docs = changes.map((c) => ({
-		seq: c.seq,
-		modelName: c.modelName,
-		op: c.op,
-		docId: c.docId ?? void 0,
-		ts
-	}));
-	if (session) {
-		await RtsChange.insertMany(docs, { session });
-		return;
-	}
-	await RtsChange.insertMany(docs);
-};
-var recordDeleteChanges = async (db, modelName, ids, session) => {
-	const uniqueIds = Array.from(new Set(ids)).filter(Boolean);
-	if (!uniqueIds.length) return;
-	const { start } = await allocateSeqRange(db, uniqueIds.length, session);
-	await insertChanges(db, uniqueIds.map((docId, idx) => ({
-		seq: start + idx,
-		modelName,
-		op: "delete",
-		docId
-	})), session);
-};
-var recordResetModel = async (db, modelName, session) => {
-	const { start } = await allocateSeqRange(db, 1, session);
-	await insertChanges(db, [{
-		seq: start,
-		modelName,
-		op: "reset_model"
-	}], session);
-};
-var captureDeleteMeta = async (query, mode) => {
-	const modelName = String(query?.model?.modelName ?? "");
-	if (!modelName || modelName.startsWith("RB") || EXCLUDED_MODEL_NAMES.has(modelName)) return;
-	if (isGlobalDb(query?.model?.db)) return;
-	const filter = typeof query.getFilter === "function" ? query.getFilter() : query.getQuery?.() ?? {};
-	const session = getQuerySession(query);
-	const findQuery = query.model.find(filter, { _id: 1 });
-	if (session && typeof findQuery.session === "function") findQuery.session(session);
-	findQuery.lean();
-	if (mode === "one") findQuery.limit(1);
-	else findQuery.limit(maxDeleteIds + 1);
-	const docs = await findQuery;
-	const ids = Array.isArray(docs) ? docs.map((d) => normalizeId(d?._id)).filter((id) => Boolean(id)) : [];
-	const reset = mode === "many" && ids.length > maxDeleteIds;
-	const meta = {
-		modelName,
-		ids: reset ? [] : ids,
-		reset,
-		session
-	};
-	deleteMetaByQuery.set(query, meta);
-};
-var flushDeleteMeta = async (query) => {
-	const meta = deleteMetaByQuery.get(query);
-	deleteMetaByQuery.delete(query);
-	if (!meta) return;
-	const db = query?.model?.db;
-	if (!db) return;
-	try {
-		if (meta.reset) await recordResetModel(db, meta.modelName, meta.session);
-		else await recordDeleteChanges(db, meta.modelName, meta.ids, meta.session);
-	} catch {
-		return;
-	}
-};
-var rtsChangeLogPlugin = (schema) => {
-	schema.pre("deleteOne", {
-		query: true,
-		document: false
-	}, async function() {
-		await captureDeleteMeta(this, "one");
-	});
-	schema.pre("deleteMany", {
-		query: true,
-		document: false
-	}, async function() {
-		await captureDeleteMeta(this, "many");
-	});
-	schema.post("deleteOne", {
-		query: true,
-		document: false
-	}, async function() {
-		await flushDeleteMeta(this);
-	});
-	schema.post("deleteMany", {
-		query: true,
-		document: false
-	}, async function() {
-		await flushDeleteMeta(this);
-	});
-	schema.post("findOneAndDelete", {
-		query: true,
-		document: false
-	}, async function(doc) {
-		const modelName = String(this?.model?.modelName ?? "");
-		if (!modelName || modelName.startsWith("RB") || EXCLUDED_MODEL_NAMES.has(modelName)) return;
-		const db = this?.model?.db;
-		if (!db) return;
-		if (isGlobalDb(db)) return;
-		const docId = normalizeId(doc?._id);
-		if (!docId) return;
-		try {
-			const session = getQuerySession(this);
-			await recordDeleteChanges(db, modelName, [docId], session);
-		} catch {
-			return;
-		}
-	});
-};
-//#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 = new Set([
-	"RBUser",
-	"RBTenant",
-	"RBOAuthRequest"
-]);
-var assertSchema = (exportName, value) => {
-	if (value instanceof mongoose$1.Schema) return value;
-	throw new Error([
-		`Expected ${exportName} to be an instance of mongoose.Schema, but it was not.`,
-		"rpcbase supports mongoose 9+ only.",
-		"Fix: ensure the project is using mongoose 9.x and that all packages resolve the same mongoose instance (try `npm ls mongoose`)."
-	].join(" "));
-};
-var getFrameworkSchemaForModelName = (modelName) => {
-	const value = models_exports[`${modelName}Schema`];
-	if (!(value instanceof mongoose$1.Schema)) return null;
-	return value;
-};
-var applyTenantPlugins = (schema) => {
-	schema.plugin(accessibleRecordsPlugin);
-	schema.plugin(mongooseAclPlugin);
-	schema.plugin(mongoPaginationPlugin);
-	schema.plugin(rtsChangeLogPlugin);
-};
-var registerSchema = (target, other, modelName, schema, scope) => {
-	if (target[modelName] || other[modelName]) throw new Error(`Duplicate model name "${modelName}" across tenant/global scopes`);
-	target[modelName] = schema;
-};
-var buildSchemasFromModules = (modules) => Object.entries(modules).filter(([key]) => key.endsWith("Schema")).map(([key, schemaValue]) => {
-	const schema = assertSchema(key, schemaValue);
-	return {
-		modelName: key.replace(/Schema$/, ""),
-		schema
-	};
+const {
+  Schema,
+  model
+} = mongoose;
+class PaginationValidationError extends Error {
+  code = "invalid_pagination";
+  statusCode = 400;
+  constructor(message, options) {
+    super(message, options);
+    this.name = "PaginationValidationError";
+  }
+}
+const isPaginationValidationError = (error) => {
+  if (!error || typeof error !== "object") return false;
+  const anyError = error;
+  return anyError.name === "PaginationValidationError" && anyError.code === "invalid_pagination" && anyError.statusCode === 400;
+};
+const DISALLOWED_MONGO_FIELD_SEGMENTS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+const PAGINATION_LIMIT_MAX = 128;
+const normalizePaginationSpec = (spec) => {
+  if (!spec || typeof spec !== "object") throw new PaginationValidationError("Invalid PaginationSpec");
+  const limit = normalizeLimit(spec.limit);
+  const direction = spec.direction ?? "next";
+  if (direction !== "next" && direction !== "prev") throw new PaginationValidationError("Invalid pagination direction");
+  if (!Array.isArray(spec.sort) || spec.sort.length === 0) throw new PaginationValidationError("Invalid pagination sort");
+  const sort = spec.sort.map(({
+    field,
+    order
+  }) => ({
+    field: assertSafeMongoFieldPath(field),
+    order: normalizeOrder(order)
+  }));
+  const seenFields = /* @__PURE__ */ new Set();
+  for (const {
+    field
+  } of sort) {
+    if (seenFields.has(field)) throw new PaginationValidationError(`Duplicate pagination sort field: ${field}`);
+    seenFields.add(field);
+  }
+  const primaryOrder = sort[0]?.order;
+  if (!seenFields.has("_id")) {
+    sort.push({
+      field: "_id",
+      order: primaryOrder
+    });
+  }
+  return {
+    ...spec,
+    limit,
+    direction,
+    sort
+  };
+};
+const normalizeLimit = (limit) => {
+  if (typeof limit !== "number" || !Number.isFinite(limit) || !Number.isInteger(limit) || limit <= 0) {
+    throw new PaginationValidationError("Invalid pagination limit");
+  }
+  if (limit > PAGINATION_LIMIT_MAX) {
+    throw new PaginationValidationError("Invalid pagination limit");
+  }
+  return limit;
+};
+const normalizeOrder = (order) => {
+  if (order !== "asc" && order !== "desc") throw new PaginationValidationError("Invalid pagination order");
+  return order;
+};
+const assertSafeMongoFieldPath = (field) => {
+  if (typeof field !== "string" || field.length === 0) throw new PaginationValidationError("Invalid pagination sort field");
+  if (field.startsWith("$")) throw new PaginationValidationError("Invalid pagination sort field");
+  const parts = field.split(".");
+  for (const part of parts) {
+    if (part.length === 0) throw new PaginationValidationError("Invalid pagination sort field");
+    if (DISALLOWED_MONGO_FIELD_SEGMENTS.has(part)) throw new PaginationValidationError("Invalid pagination sort field");
+    if (!/^[a-zA-Z0-9_]+$/.test(part)) throw new PaginationValidationError("Invalid pagination sort field");
+  }
+  return field;
+};
+const encodePaginationCursor = (spec, node, options) => {
+  const normalized = normalizePaginationSpec(spec);
+  const values = /* @__PURE__ */ Object.create(null);
+  for (const {
+    field
+  } of normalized.sort) {
+    const value = readFieldValue(node, field);
+    if (typeof value === "undefined") {
+      throw new Error(`Pagination cursor encode failed (missing field: ${field})`);
+    }
+    values[field] = encodeCursorValue(field, value);
+  }
+  const payload = {
+    v: 1,
+    values
+  };
+  const payloadB64 = Buffer.from(JSON.stringify(payload), "utf8").toString("base64url");
+  const sigB64 = signCursorPayloadB64(payloadB64, options.signingSecret);
+  return `${payloadB64}.${sigB64}`;
+};
+const decodePaginationCursor = (spec, cursor, options) => {
+  const normalized = normalizePaginationSpec(spec);
+  const [payloadB64, sigB64, ...rest] = cursor.split(".");
+  if (rest.length > 0) throw new PaginationValidationError("Invalid pagination cursor format");
+  if (!sigB64) throw new PaginationValidationError("Invalid pagination cursor format");
+  verifyCursorSignature(payloadB64, sigB64, options.signingSecret);
+  const payloadRaw = Buffer.from(payloadB64, "base64url").toString("utf8");
+  let payloadUnknown;
+  try {
+    payloadUnknown = JSON.parse(payloadRaw);
+  } catch {
+    throw new PaginationValidationError("Invalid pagination cursor payload");
+  }
+  if (!payloadUnknown || typeof payloadUnknown !== "object") throw new PaginationValidationError("Invalid pagination cursor payload");
+  const payload = payloadUnknown;
+  if (payload.v !== 1) throw new PaginationValidationError("Unsupported pagination cursor version");
+  if (!payload.values || typeof payload.values !== "object") throw new PaginationValidationError("Invalid pagination cursor payload");
+  const decoded = /* @__PURE__ */ Object.create(null);
+  for (const {
+    field
+  } of normalized.sort) {
+    if (!Object.prototype.hasOwnProperty.call(payload.values, field)) {
+      throw new PaginationValidationError(`Pagination cursor missing field: ${field}`);
+    }
+    const encodedValue = payload.values[field];
+    decoded[field] = decodeCursorValue(field, encodedValue);
+  }
+  return decoded;
+};
+const signCursorPayloadB64 = (payloadB64, secret) => {
+  return createHmac("sha256", secret).update(payloadB64, "utf8").digest("base64url");
+};
+const verifyCursorSignature = (payloadB64, sigB64, secret) => {
+  const expectedSigB64 = signCursorPayloadB64(payloadB64, secret);
+  const a3 = Buffer.from(sigB64, "utf8");
+  const b3 = Buffer.from(expectedSigB64, "utf8");
+  if (a3.length !== b3.length || !timingSafeEqual(a3, b3)) {
+    throw new PaginationValidationError("Invalid pagination cursor signature");
+  }
+};
+const unwrapCursorComparableValue = (value) => {
+  if (value === null || typeof value !== "object") return value;
+  if (value instanceof Date || value instanceof Types.ObjectId) return value;
+  let current = value;
+  for (let depth = 0; depth < 4; depth += 1) {
+    if (!current || typeof current !== "object") return current;
+    if (current instanceof Date || current instanceof Types.ObjectId) return current;
+    if (!("_id" in current)) return current;
+    current = current._id;
+  }
+  return current;
+};
+const encodeCursorValue = (field, value) => {
+  const comparableValue = unwrapCursorComparableValue(value);
+  if (comparableValue === null) return null;
+  if (field === "_id") {
+    if (comparableValue instanceof Types.ObjectId) return {
+      $oid: comparableValue.toHexString()
+    };
+    if (typeof comparableValue === "string") return comparableValue;
+    throw new Error("Pagination cursor encode failed (_id must be an ObjectId or string)");
+  }
+  if (comparableValue instanceof Date) return {
+    $date: comparableValue.toISOString()
+  };
+  if (typeof comparableValue === "string" || typeof comparableValue === "number" || typeof comparableValue === "boolean") {
+    return comparableValue;
+  }
+  if (comparableValue instanceof Types.ObjectId) return {
+    $oid: comparableValue.toHexString()
+  };
+  throw new Error(`Unsupported pagination cursor value type for field: ${field}`);
+};
+const decodeCursorValue = (field, value) => {
+  if (value === null) return null;
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number" || typeof value === "boolean") return value;
+  if (!value || typeof value !== "object") throw new PaginationValidationError(`Invalid pagination cursor value for field: ${field}`);
+  if ("$date" in value) {
+    if (typeof value.$date !== "string") throw new PaginationValidationError(`Invalid pagination cursor date for field: ${field}`);
+    const d3 = new Date(value.$date);
+    if (Number.isNaN(d3.getTime())) throw new PaginationValidationError(`Invalid pagination cursor date for field: ${field}`);
+    return d3;
+  }
+  if ("$oid" in value) {
+    if (typeof value.$oid !== "string" || !Types.ObjectId.isValid(value.$oid)) {
+      throw new PaginationValidationError(`Invalid pagination cursor ObjectId for field: ${field}`);
+    }
+    return new Types.ObjectId(value.$oid);
+  }
+  throw new PaginationValidationError(`Invalid pagination cursor value for field: ${field}`);
+};
+const readFieldValue = (node, field) => {
+  if (!node || typeof node !== "object") return void 0;
+  if ("get" in node && typeof node.get === "function") {
+    return node.get(field);
+  }
+  return field.split(".").reduce((acc, key) => {
+    if (!acc || typeof acc !== "object") return void 0;
+    return acc[key];
+  }, node);
+};
+const compileMongoPagination = (spec, options) => {
+  const normalized = normalizePaginationSpec(spec);
+  const mongoLimit = normalized.limit + 1;
+  const mongoSort = toMongoSort(normalized);
+  if (normalized.cursor == null) {
+    return {
+      spec: normalized,
+      mongoFilterDelta: {},
+      mongoSort,
+      mongoLimit
+    };
+  }
+  if (typeof normalized.cursor !== "string" || normalized.cursor.length === 0) {
+    throw new PaginationValidationError("Invalid pagination cursor");
+  }
+  const cursorValues = decodePaginationCursor(normalized, normalized.cursor, options.cursor);
+  const mongoFilterDelta = buildKeysetFilterDelta(normalized, cursorValues);
+  return {
+    spec: normalized,
+    mongoFilterDelta,
+    mongoSort,
+    mongoLimit
+  };
+};
+const toMongoSort = (spec) => {
+  const mongoSort = /* @__PURE__ */ Object.create(null);
+  for (const {
+    field,
+    order
+  } of spec.sort) {
+    const forQueryOrder = spec.direction === "prev" ? invertOrder(order) : order;
+    mongoSort[field] = forQueryOrder === "asc" ? 1 : -1;
+  }
+  return mongoSort;
+};
+const buildKeysetFilterDelta = (spec, cursorValues) => {
+  const branches = [];
+  for (let i = 0; i < spec.sort.length; i++) {
+    const current = spec.sort[i];
+    if (!current) continue;
+    const and = [];
+    for (let j = 0; j < i; j++) {
+      const prev = spec.sort[j];
+      if (!prev) continue;
+      const eq = /* @__PURE__ */ Object.create(null);
+      eq[prev.field] = cursorValues[prev.field];
+      and.push(eq);
+    }
+    const op = getKeysetOp(current.order, spec.direction);
+    const cmpOp = /* @__PURE__ */ Object.create(null);
+    cmpOp[op] = cursorValues[current.field];
+    const cmp = /* @__PURE__ */ Object.create(null);
+    cmp[current.field] = cmpOp;
+    and.push(cmp);
+    branches.push(and.length === 1 ? and[0] : {
+      $and: and
+    });
+  }
+  return {
+    $or: branches
+  };
+};
+const getKeysetOp = (order, direction) => {
+  if (direction === "next") return order === "asc" ? "$gt" : "$lt";
+  return order === "asc" ? "$lt" : "$gt";
+};
+const invertOrder = (order) => {
+  return order === "asc" ? "desc" : "asc";
+};
+const materializeMongoPagination = (compiled, fetchedNodes, options) => {
+  const limit = compiled.spec.limit;
+  const hasMore = fetchedNodes.length > limit;
+  const trimmed = fetchedNodes.slice(0, limit);
+  const nodes = compiled.spec.direction === "prev" ? trimmed.reverse() : trimmed;
+  const hasPrevPage = compiled.spec.direction === "next" ? Boolean(compiled.spec.cursor) : hasMore;
+  const hasNextPage = compiled.spec.direction === "next" ? hasMore : Boolean(compiled.spec.cursor);
+  const pageInfo = {
+    hasNextPage,
+    hasPrevPage
+  };
+  if (nodes.length === 0) {
+    return {
+      nodes,
+      pageInfo
+    };
+  }
+  if (hasPrevPage) {
+    pageInfo.prevCursor = encodePaginationCursor(compiled.spec, nodes[0], options.cursor);
+  }
+  if (hasNextPage) {
+    pageInfo.nextCursor = encodePaginationCursor(compiled.spec, nodes[nodes.length - 1], options.cursor);
+  }
+  return {
+    nodes,
+    pageInfo
+  };
+};
+const MongoAdapter = {
+  applyPagination: (query, compiled) => {
+    query.where(compiled.mongoFilterDelta);
+    query.sort(compiled.mongoSort);
+    query.limit(compiled.mongoLimit);
+    return query;
+  }
+};
+const paginateMongoQuery = async (query, pagination, options) => {
+  const compiled = compileMongoPagination(pagination, {
+    cursor: options.cursor
+  });
+  MongoAdapter.applyPagination(query, compiled);
+  const fetchedNodes = await query.exec();
+  if (!Array.isArray(fetchedNodes)) {
+    throw new Error("paginateMongoQuery expects query.exec() to return an array");
+  }
+  return materializeMongoPagination(compiled, fetchedNodes, {
+    cursor: options.cursor
+  });
+};
+const getQueryOptions$1 = (query) => {
+  if (!query || typeof query !== "object") return void 0;
+  if (!("getOptions" in query) || typeof query.getOptions !== "function") return void 0;
+  return query.getOptions();
+};
+const getPaginationFromOptions = (query) => {
+  const options = getQueryOptions$1(query);
+  return options?.pagination;
+};
+const getCursorFromOptions = (query) => {
+  const options = getQueryOptions$1(query);
+  return options?.paginationCursor;
+};
+const mongoPaginationPlugin = (schema, pluginOptions) => {
+  schema.query.paginate = async function(pagination, options) {
+    const spec = pagination ?? getPaginationFromOptions(this);
+    if (!spec) throw new Error("Missing pagination spec");
+    const cursor = options?.cursor ?? getCursorFromOptions(this) ?? pluginOptions?.cursor;
+    if (!cursor?.signingSecret) throw new Error("Missing pagination cursor signingSecret");
+    return await paginateMongoQuery(this, spec, {
+      cursor
+    });
+  };
+};
+const buildSearchTextStage = (options) => {
+  const index = options.index.trim();
+  if (!index) throw new Error("Missing search index name");
+  const query = options.query.trim();
+  if (!query) throw new Error("Missing search query");
+  const stage = {
+    $search: {
+      index,
+      text: {
+        query,
+        path: options.path
+      }
+    }
+  };
+  if (options.highlightPath) {
+    stage.$search.highlight = {
+      path: options.highlightPath
+    };
+  }
+  return stage;
+};
+const searchMetaProjection = () => {
+  return {
+    score: {
+      $meta: "searchScore"
+    },
+    highlights: {
+      $meta: "searchHighlights"
+    }
+  };
+};
+const listResultHasIndex = (listResult, name) => {
+  if (!listResult || typeof listResult !== "object") return false;
+  if (!("cursor" in listResult)) return false;
+  const cursor = listResult.cursor;
+  if (!cursor || typeof cursor !== "object") return false;
+  const firstBatch = cursor.firstBatch;
+  if (!Array.isArray(firstBatch)) return false;
+  return firstBatch.some((idx) => idx && typeof idx === "object" && "name" in idx && idx.name === name);
+};
+const isIndexAlreadyExistsError = (error) => {
+  if (!error || typeof error !== "object") return false;
+  const codeName = "codeName" in error ? error.codeName : void 0;
+  if (codeName === "IndexAlreadyExists") return true;
+  const message = "message" in error ? String(error.message ?? "") : "";
+  return /already exists/i.test(message);
+};
+const ensureSearchIndex = async (params) => {
+  const collection = params.collection.trim();
+  if (!collection) throw new Error("Missing collection name");
+  const name = params.name.trim();
+  if (!name) throw new Error("Missing search index name");
+  let listResult;
+  try {
+    listResult = await params.db.command({
+      listSearchIndexes: collection
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`listSearchIndexes failed for "${collection}": ${message}`);
+  }
+  if (listResultHasIndex(listResult, name)) {
+    return {
+      created: false
+    };
+  }
+  try {
+    await params.db.command({
+      createSearchIndexes: collection,
+      indexes: [{
+        name,
+        definition: params.definition
+      }]
+    });
+  } catch (error) {
+    if (isIndexAlreadyExistsError(error)) {
+      return {
+        created: false
+      };
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`createSearchIndexes failed for "${collection}" (index "${name}"): ${message}`);
+  }
+  return {
+    created: true
+  };
+};
+const getAppName$1 = (env = process.env) => {
+  const appName = env.APP_NAME?.trim();
+  if (!appName) {
+    throw new Error("Missing APP_NAME");
+  }
+  return appName;
+};
+const GLOBAL_DB_SUFFIX = "-global-db";
+const getGlobalDbName = (env = process.env) => {
+  return `${getAppName$1(env)}${GLOBAL_DB_SUFFIX}`;
+};
+const getTenantDbName = (tenantId, env = process.env) => {
+  return `${getAppName$1(env)}-${tenantId.trim()}-db`;
+};
+const getMongoUrl = (env = process.env) => {
+  const explicitUrl = env.MONGODB_URL ?? env.MONGO_URL ?? env.MONGODB_URI ?? env.DB_URL;
+  if (explicitUrl && explicitUrl.trim()) {
+    return explicitUrl.trim();
+  }
+  const port = env.DB_PORT?.trim();
+  if (!port) throw new Error("Missing Mongo connection details (MONGODB_URL/MONGO_URL/MONGODB_URI/DB_URL/DB_PORT)");
+  const host = env.DB_HOST?.trim() || "localhost";
+  return `mongodb://${host}:${port}`;
+};
+const connections = /* @__PURE__ */ new Map();
+let rootConnection = null;
+const CONNECTION_MAX_LISTENERS = 50;
+const waitForOpen = async (connection) => {
+  if (connection.readyState === 1) return;
+  if (connection.getMaxListeners() < CONNECTION_MAX_LISTENERS) {
+    connection.setMaxListeners(CONNECTION_MAX_LISTENERS);
+  }
+  await new Promise((resolve, reject) => {
+    connection.once("open", resolve);
+    connection.once("error", reject);
+  });
+};
+const ensureMongooseConnection = async (dbName) => {
+  const normalizedDbName = dbName.trim();
+  if (!normalizedDbName) {
+    throw new Error("Missing dbName");
+  }
+  const existing = connections.get(normalizedDbName);
+  if (existing) {
+    await waitForOpen(existing);
+    return existing;
+  }
+  if (!rootConnection) {
+    const mongoUrl = getMongoUrl();
+    rootConnection = mongoose.createConnection(mongoUrl, {
+      sanitizeFilter: true,
+      dbName: normalizedDbName
+    });
+  }
+  await waitForOpen(rootConnection);
+  const connection = rootConnection.name === normalizedDbName ? rootConnection : rootConnection.useDb(normalizedDbName, {
+    useCache: true
+  });
+  await waitForOpen(connection);
+  connections.set(normalizedDbName, connection);
+  return connection;
+};
+const RTS_COUNTER_ID = "rts";
+const EXCLUDED_MODEL_NAMES = /* @__PURE__ */ new Set(["RBRtsChange", "RBRtsCounter"]);
+const maxDeleteIdsRaw = process.env.RB_RTS_DELETE_LOG_MAX_IDS ?? "";
+const maxDeleteIds = Number.isFinite(Number(maxDeleteIdsRaw)) ? Math.max(1, Math.floor(Number(maxDeleteIdsRaw))) : 5e3;
+const deleteMetaByQuery = /* @__PURE__ */ new WeakMap();
+const hasToString = (value) => {
+  if (typeof value !== "object" || value === null) return false;
+  const maybe = value;
+  return typeof maybe.toString === "function";
+};
+const normalizeId = (id) => {
+  if (!id) return null;
+  if (typeof id === "string") return id;
+  if (hasToString(id)) return id.toString();
+  return null;
+};
+const getDbName = (db) => {
+  if (!db || typeof db !== "object") return "";
+  const maybe = db;
+  const raw = maybe.name ?? maybe.db?.databaseName;
+  return typeof raw === "string" ? raw : "";
+};
+const isGlobalDb = (db) => getDbName(db).endsWith(GLOBAL_DB_SUFFIX);
+const getQuerySession = (query) => {
+  const opts = typeof query.getOptions === "function" ? query.getOptions() : void 0;
+  if (!opts || typeof opts !== "object") return void 0;
+  const session = opts.session;
+  if (!session || typeof session !== "object") return void 0;
+  return session;
+};
+const getRtsModels = (db) => {
+  const RtsCounter = db.models.RBRtsCounter ?? db.model("RBRtsCounter", RBRtsCounterSchema);
+  const RtsChange = db.models.RBRtsChange ?? db.model("RBRtsChange", RBRtsChangeSchema);
+  return {
+    RtsCounter,
+    RtsChange
+  };
+};
+const allocateSeqRange = async (db, count, session) => {
+  const {
+    RtsCounter
+  } = getRtsModels(db);
+  const updated = await RtsCounter.findOneAndUpdate({
+    _id: RTS_COUNTER_ID
+  }, {
+    $inc: {
+      seq: count
+    }
+  }, {
+    upsert: true,
+    returnDocument: "after",
+    setDefaultsOnInsert: true,
+    projection: {
+      seq: 1
+    },
+    session
+  }).lean();
+  const end = Number(updated?.seq ?? 0);
+  const start = end - count + 1;
+  return {
+    start,
+    end
+  };
+};
+const insertChanges = async (db, changes, session) => {
+  if (!changes.length) return;
+  const {
+    RtsChange
+  } = getRtsModels(db);
+  const ts = /* @__PURE__ */ new Date();
+  const docs = changes.map((c3) => ({
+    seq: c3.seq,
+    modelName: c3.modelName,
+    op: c3.op,
+    docId: c3.docId ?? void 0,
+    ts
+  }));
+  if (session) {
+    await RtsChange.insertMany(docs, {
+      session
+    });
+    return;
+  }
+  await RtsChange.insertMany(docs);
+};
+const recordDeleteChanges = async (db, modelName, ids, session) => {
+  const uniqueIds = Array.from(new Set(ids)).filter(Boolean);
+  if (!uniqueIds.length) return;
+  const {
+    start
+  } = await allocateSeqRange(db, uniqueIds.length, session);
+  await insertChanges(db, uniqueIds.map((docId, idx) => ({
+    seq: start + idx,
+    modelName,
+    op: "delete",
+    docId
+  })), session);
+};
+const recordResetModel = async (db, modelName, session) => {
+  const {
+    start
+  } = await allocateSeqRange(db, 1, session);
+  await insertChanges(db, [{
+    seq: start,
+    modelName,
+    op: "reset_model"
+  }], session);
+};
+const captureDeleteMeta = async (query, mode) => {
+  const modelName = String(query?.model?.modelName ?? "");
+  if (!modelName || modelName.startsWith("RB") || EXCLUDED_MODEL_NAMES.has(modelName)) return;
+  if (isGlobalDb(query?.model?.db)) return;
+  const filter = typeof query.getFilter === "function" ? query.getFilter() : query.getQuery?.() ?? {};
+  const session = getQuerySession(query);
+  const findQuery = query.model.find(filter, {
+    _id: 1
+  });
+  if (session && typeof findQuery.session === "function") {
+    findQuery.session(session);
+  }
+  findQuery.lean();
+  if (mode === "one") {
+    findQuery.limit(1);
+  } else {
+    findQuery.limit(maxDeleteIds + 1);
+  }
+  const docs = await findQuery;
+  const ids = Array.isArray(docs) ? docs.map((d3) => normalizeId(d3?._id)).filter((id) => Boolean(id)) : [];
+  const reset = mode === "many" && ids.length > maxDeleteIds;
+  const trimmedIds = reset ? [] : ids;
+  const meta = {
+    modelName,
+    ids: trimmedIds,
+    reset,
+    session
+  };
+  deleteMetaByQuery.set(query, meta);
+};
+const flushDeleteMeta = async (query) => {
+  const meta = deleteMetaByQuery.get(query);
+  deleteMetaByQuery.delete(query);
+  if (!meta) return;
+  const db = query?.model?.db;
+  if (!db) return;
+  try {
+    if (meta.reset) {
+      await recordResetModel(db, meta.modelName, meta.session);
+    } else {
+      await recordDeleteChanges(db, meta.modelName, meta.ids, meta.session);
+    }
+  } catch {
+    return;
+  }
+};
+const rtsChangeLogPlugin = (schema) => {
+  schema.pre("deleteOne", {
+    query: true,
+    document: false
+  }, async function() {
+    await captureDeleteMeta(this, "one");
+  });
+  schema.pre("deleteMany", {
+    query: true,
+    document: false
+  }, async function() {
+    await captureDeleteMeta(this, "many");
+  });
+  schema.post("deleteOne", {
+    query: true,
+    document: false
+  }, async function() {
+    await flushDeleteMeta(this);
+  });
+  schema.post("deleteMany", {
+    query: true,
+    document: false
+  }, async function() {
+    await flushDeleteMeta(this);
+  });
+  schema.post("findOneAndDelete", {
+    query: true,
+    document: false
+  }, async function(doc) {
+    const modelName = String(this?.model?.modelName ?? "");
+    if (!modelName || modelName.startsWith("RB") || EXCLUDED_MODEL_NAMES.has(modelName)) return;
+    const db = this?.model?.db;
+    if (!db) return;
+    if (isGlobalDb(db)) return;
+    const docId = normalizeId(doc?._id);
+    if (!docId) return;
+    try {
+      const session = getQuerySession(this);
+      await recordDeleteChanges(db, modelName, [docId], session);
+    } catch {
+      return;
+    }
+  });
+};
+const isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+const 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]
+  };
+};
+const getQueryOptions = (query) => {
+  if (!query || typeof query !== "object") return void 0;
+  if (!("getOptions" in query) || typeof query.getOptions !== "function") return void 0;
+  return query.getOptions();
+};
+const getStoredAclFromQuery = (query) => {
+  const options = getQueryOptions(query);
+  const raw = options?.rbAcl;
+  if (!isRecord(raw)) return null;
+  if (!("ability" in raw)) return null;
+  return raw;
+};
+const 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;
+};
+const 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]);
+};
+const 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
+  });
+};
+const 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);
+};
+const patchAggregateAcl = () => {
+  const globalKey = /* @__PURE__ */ Symbol.for("@rpcbase/db/acl/mongooseAggregateAclPatched");
+  const globalState = globalThis;
+  if (globalState[globalKey]) return;
+  globalState[globalKey] = true;
+  const AggregatePrototype = mongoose.Aggregate.prototype;
+  if (typeof AggregatePrototype.acl === "function") return;
+  AggregatePrototype.acl = function(ability, action = "read") {
+    this.option({
+      rbAcl: {
+        ability,
+        action
+      }
+    });
+    return this;
+  };
+};
+const createModelAclProxy = (model2, ability) => {
+  return new Proxy(model2, {
+    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;
+      };
+    }
+  });
+};
+const 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");
+  });
+};
+let cachedModels = null;
+const DEFAULT_GLOBAL_RB_MODEL_NAMES_SET = /* @__PURE__ */ new Set(["RBUser", "RBTenant", "RBOAuthRequest"]);
+const assertSchema = (exportName, value) => {
+  if (value instanceof mongoose.Schema) return value;
+  throw new Error([`Expected ${exportName} to be an instance of mongoose.Schema, but it was not.`, "rpcbase supports mongoose 9+ only.", "Fix: ensure the project is using mongoose 9.x and that all packages resolve the same mongoose instance (try `npm ls mongoose`)."].join(" "));
+};
+const getFrameworkSchemaForModelName = (modelName) => {
+  const exportName = `${modelName}Schema`;
+  const value = frameworkSchemas[exportName];
+  if (!(value instanceof mongoose.Schema)) return null;
+  return value;
+};
+const applyTenantPlugins = (schema) => {
+  schema.plugin(accessibleRecordsPlugin);
+  schema.plugin(mongooseAclPlugin);
+  schema.plugin(mongoPaginationPlugin);
+  schema.plugin(rtsChangeLogPlugin);
+};
+const registerSchema = (target, other, modelName, schema, scope) => {
+  if (target[modelName] || other[modelName]) {
+    throw new Error(`Duplicate model name "${modelName}" across tenant/global scopes`);
+  }
+  target[modelName] = schema;
+};
+const buildSchemasFromModules = (modules) => Object.entries(modules).filter(([key]) => key.endsWith("Schema")).map(([key, schemaValue]) => {
+  const schema = assertSchema(key, schemaValue);
+  const modelName = key.replace(/Schema$/, "");
+  return {
+    modelName,
+    schema
+  };
+});
+const registerModels = ({
+  tenant,
+  global
+}, options = {}) => {
+  registerPoliciesFromModules(frameworkSchemas);
+  registerPoliciesFromModules(tenant);
+  const tenantSchemas = {};
+  const globalSchemas = {};
+  const allowReservedRbModelNames = options.allowReservedRbModelNames === true;
+  for (const {
+    modelName,
+    schema
+  } of buildSchemasFromModules(frameworkSchemas)) {
+    if (DEFAULT_GLOBAL_RB_MODEL_NAMES_SET.has(modelName)) {
+      const cloned = schema.clone();
+      registerSchema(globalSchemas, tenantSchemas, modelName, cloned);
+    } else {
+      const cloned = schema.clone();
+      applyTenantPlugins(cloned);
+      registerSchema(tenantSchemas, globalSchemas, modelName, cloned);
+    }
+  }
+  for (const {
+    modelName,
+    schema
+  } of buildSchemasFromModules(tenant)) {
+    if (modelName === "RBUser" || modelName === "RBTenant") {
+      throw new Error(`Invalid tenant model name "${modelName}". RBUser/RBTenant are global models.`);
+    }
+    if (modelName.startsWith("RB")) {
+      const frameworkSchema = getFrameworkSchemaForModelName(modelName);
+      if (frameworkSchema && schema === frameworkSchema) continue;
+      if (!allowReservedRbModelNames) {
+        throw new Error(`Invalid tenant model name "${modelName}". RB* models are reserved for rpcbase.`);
+      }
+    }
+    const cloned = schema.clone();
+    applyTenantPlugins(cloned);
+    registerSchema(tenantSchemas, globalSchemas, modelName, cloned);
+  }
+  for (const {
+    modelName,
+    schema
+  } of buildSchemasFromModules(global ?? {})) {
+    if (modelName.startsWith("RB")) {
+      const frameworkSchema = getFrameworkSchemaForModelName(modelName);
+      if (frameworkSchema && schema === frameworkSchema) continue;
+      if (!allowReservedRbModelNames) {
+        throw new Error(`Invalid global model name "${modelName}". RB* models are reserved for rpcbase.`);
+      }
+    }
+    const cloned = schema.clone();
+    registerSchema(globalSchemas, tenantSchemas, modelName, cloned);
+  }
+  const allSchemas = {
+    ...globalSchemas,
+    ...tenantSchemas
+  };
+  for (const [modelName, schema] of Object.entries(allSchemas)) {
+    if (!mongoose.models[modelName]) {
+      mongoose.model(modelName, schema);
+    }
+  }
+  cachedModels = {
+    tenant: {
+      ...cachedModels?.tenant ?? {},
+      ...tenantSchemas
+    },
+    global: {
+      ...cachedModels?.global ?? {},
+      ...globalSchemas
+    }
+  };
+};
+const getRegisteredModels = (scope) => {
+  if (!cachedModels) {
+    throw new Error("Models not registered. Call createModels(...) once at startup (or import your models module) before using models.get.");
+  }
+  return cachedModels[scope];
+};
+const 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);
+  }
+  return modelConnection.models[modelName];
+};
+const normalizeTenantId$1 = (value) => {
+  if (typeof value !== "string") return null;
+  const tenantId = value.trim();
+  return tenantId || null;
+};
+const getTenantIdFromLoadModelCtx = (ctx) => {
+  const tenantId = normalizeTenantId$1(ctx.tenantId) ?? normalizeTenantId$1(ctx.req?.session?.user?.currentTenantId);
+  assert(tenantId, "Tenant ID is missing from ctx (expected ctx.tenantId or ctx.req.session.user.currentTenantId)");
+  return tenantId;
+};
+const models = {
+  register: registerModels,
+  getUnsafe: async (modelName, ctx) => {
+    const tenantId = getTenantIdFromLoadModelCtx(ctx);
+    const dbName = getTenantDbName(tenantId);
+    return loadModelFromDb(modelName, dbName, "tenant");
+  },
+  get: async (modelName, ctx) => {
+    const model2 = await models.getUnsafe(modelName, ctx);
+    const resolvedAbility = ctx.ability;
+    const isProtected = hasRegisteredPolicy(modelName);
+    if (!isProtected) {
+      return model2;
+    }
+    if (!resolvedAbility) {
+      throw new Error(`Model "${modelName}" is ACL-protected. Set ctx.ability or use models.getUnsafe(...) explicitly.`);
+    }
+    if (typeof model2.acl !== "function") return model2;
+    return model2.acl(resolvedAbility);
+  },
+  getGlobal: async (modelName, ctx) => {
+    const dbName = getGlobalDbName();
+    return loadModelFromDb(modelName, dbName, "global");
+  }
+};
+const createModels = (modules, options) => {
+  registerModels(modules, options);
+  const get = (async (modelNameOrNames, ctx) => {
+    if (Array.isArray(modelNameOrNames)) {
+      return Promise.all(modelNameOrNames.map((modelName) => models.get(modelName, ctx)));
+    }
+    return models.get(modelNameOrNames, ctx);
+  });
+  const getUnsafe = (async (modelNameOrNames, ctx) => {
+    if (Array.isArray(modelNameOrNames)) {
+      return Promise.all(modelNameOrNames.map((modelName) => models.getUnsafe(modelName, ctx)));
+    }
+    return models.getUnsafe(modelNameOrNames, ctx);
+  });
+  const getGlobal = (async (modelNameOrNames, ctx) => {
+    if (Array.isArray(modelNameOrNames)) {
+      return Promise.all(modelNameOrNames.map((modelName) => models.getGlobal(modelName, ctx)));
+    }
+    return models.getGlobal(modelNameOrNames, ctx);
+  });
+  return {
+    register: (nextModules, nextOptions) => registerModels(nextModules, nextOptions),
+    get,
+    getUnsafe,
+    getGlobal
+  };
+};
+const getAppName = () => {
+  const appName = process.env.APP_NAME?.trim();
+  assert(appName, "Missing APP_NAME");
+  return appName;
+};
+const normalizeTenantId = (tenantId) => {
+  const normalized = tenantId.trim();
+  assert(normalized, "Tenant ID is missing");
+  return normalized;
+};
+const getTenantFilesystemDbName = (tenantId) => `${getAppName()}-${normalizeTenantId(tenantId)}-filesystem-db`;
+const getTenantFilesystemDb = async (tenantId) => ensureMongooseConnection(getTenantFilesystemDbName(tenantId));
+const getTenantFilesystemDbFromCtx = async (ctx) => {
+  const tenantId = getTenantIdFromLoadModelCtx(ctx);
+  return getTenantFilesystemDb(tenantId);
+};
+const buildTenantLoadModelCtx = (tenantId) => ({
+  req: {
+    session: {
+      user: {
+        currentTenantId: tenantId
+      }
+    }
+  }
 });
-var registerModels = ({ tenant, global }, options = {}) => {
-	registerPoliciesFromModules(models_exports);
-	registerPoliciesFromModules(tenant);
-	const tenantSchemas = {};
-	const globalSchemas = {};
-	const allowReservedRbModelNames = options.allowReservedRbModelNames === true;
-	for (const { modelName, schema } of buildSchemasFromModules(models_exports)) if (DEFAULT_GLOBAL_RB_MODEL_NAMES_SET.has(modelName)) registerSchema(globalSchemas, tenantSchemas, modelName, schema.clone(), "global");
-	else {
-		const cloned = schema.clone();
-		applyTenantPlugins(cloned);
-		registerSchema(tenantSchemas, globalSchemas, modelName, cloned, "tenant");
-	}
-	for (const { modelName, schema } of buildSchemasFromModules(tenant)) {
-		if (modelName === "RBUser" || modelName === "RBTenant") throw new Error(`Invalid tenant model name "${modelName}". RBUser/RBTenant are global models.`);
-		if (modelName.startsWith("RB")) {
-			const frameworkSchema = getFrameworkSchemaForModelName(modelName);
-			if (frameworkSchema && schema === frameworkSchema) continue;
-			if (!allowReservedRbModelNames) throw new Error(`Invalid tenant model name "${modelName}". RB* models are reserved for rpcbase.`);
-		}
-		const cloned = schema.clone();
-		applyTenantPlugins(cloned);
-		registerSchema(tenantSchemas, globalSchemas, modelName, cloned, "tenant");
-	}
-	for (const { modelName, schema } of buildSchemasFromModules(global ?? {})) {
-		if (modelName.startsWith("RB")) {
-			const frameworkSchema = getFrameworkSchemaForModelName(modelName);
-			if (frameworkSchema && schema === frameworkSchema) continue;
-			if (!allowReservedRbModelNames) throw new Error(`Invalid global model name "${modelName}". RB* models are reserved for rpcbase.`);
-		}
-		registerSchema(globalSchemas, tenantSchemas, modelName, schema.clone(), "global");
-	}
-	const allSchemas = {
-		...globalSchemas,
-		...tenantSchemas
-	};
-	for (const [modelName, schema] of Object.entries(allSchemas)) if (!mongoose$1.models[modelName]) mongoose$1.model(modelName, schema);
-	cachedModels = {
-		tenant: {
-			...cachedModels?.tenant ?? {},
-			...tenantSchemas
-		},
-		global: {
-			...cachedModels?.global ?? {},
-			...globalSchemas
-		}
-	};
-};
-var getRegisteredModels = (scope) => {
-	if (!cachedModels) throw new Error("Models not registered. Call createModels(...) once at startup (or import your models module) before using models.get.");
-	return cachedModels[scope];
-};
-//#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);
-	return modelConnection.models[modelName];
-};
-var normalizeTenantId$1 = (value) => {
-	if (typeof value !== "string") return null;
-	return value.trim() || null;
-};
-var getTenantIdFromLoadModelCtx = (ctx) => {
-	const tenantId = normalizeTenantId$1(ctx.tenantId) ?? normalizeTenantId$1(ctx.req?.session?.user?.currentTenantId);
-	assert(tenantId, "Tenant ID is missing from ctx (expected ctx.tenantId or ctx.req.session.user.currentTenantId)");
-	return tenantId;
-};
-var models = {
-	register: registerModels,
-	getUnsafe: async (modelName, ctx) => {
-		return 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);
-	},
-	getGlobal: async (modelName, ctx) => {
-		return loadModelFromDb(modelName, getGlobalDbName(), "global");
-	}
-};
-//#endregion
-//#region src/createModels.ts
-var createModels = (modules, options) => {
-	registerModels(modules, options);
-	const get = (async (modelNameOrNames, ctx) => {
-		if (Array.isArray(modelNameOrNames)) return Promise.all(modelNameOrNames.map((modelName) => models.get(modelName, ctx)));
-		return models.get(modelNameOrNames, ctx);
-	});
-	const getUnsafe = (async (modelNameOrNames, ctx) => {
-		if (Array.isArray(modelNameOrNames)) return Promise.all(modelNameOrNames.map((modelName) => models.getUnsafe(modelName, ctx)));
-		return models.getUnsafe(modelNameOrNames, ctx);
-	});
-	const getGlobal = (async (modelNameOrNames, ctx) => {
-		if (Array.isArray(modelNameOrNames)) return Promise.all(modelNameOrNames.map((modelName) => models.getGlobal(modelName, ctx)));
-		return models.getGlobal(modelNameOrNames, ctx);
-	});
-	return {
-		register: (nextModules, nextOptions) => registerModels(nextModules, nextOptions),
-		get,
-		getUnsafe,
-		getGlobal
-	};
-};
-//#endregion
-//#region src/tenantFilesystemDb.ts
-var getAppName = () => {
-	const appName = process.env.APP_NAME?.trim();
-	assert(appName, "Missing APP_NAME");
-	return appName;
-};
-var normalizeTenantId = (tenantId) => {
-	const normalized = tenantId.trim();
-	assert(normalized, "Tenant ID is missing");
-	return normalized;
-};
-var getTenantFilesystemDbName = (tenantId) => `${getAppName()}-${normalizeTenantId(tenantId)}-filesystem-db`;
-var getTenantFilesystemDb = async (tenantId) => ensureMongooseConnection(getTenantFilesystemDbName(tenantId));
-var getTenantFilesystemDbFromCtx = async (ctx) => {
-	return getTenantFilesystemDb(getTenantIdFromLoadModelCtx(ctx));
-};
-//#endregion
-//#region src/transactions.ts
-var buildTenantLoadModelCtx = (tenantId) => ({ req: { session: { user: { currentTenantId: tenantId } } } });
 async function withTransaction(scope, fn, options) {
-	const normalizedTenantId = (() => {
-		if (typeof scope === "string") return scope.trim();
-		if ("tenantId" in scope) return scope.tenantId.trim();
-		return getTenantIdFromLoadModelCtx(scope.ctx);
-	})();
-	if (!normalizedTenantId) throw new Error("Tenant ID is missing");
-	const tenantDbName = getTenantDbName(normalizedTenantId);
-	const globalDbName = getGlobalDbName();
-	const filesystemDbName = getTenantFilesystemDbName(normalizedTenantId);
-	const tenantDb = await ensureMongooseConnection(tenantDbName);
-	const globalDb = await ensureMongooseConnection(globalDbName);
-	const filesystemDb = await ensureMongooseConnection(filesystemDbName);
-	const session = await tenantDb.startSession();
-	const tenantCtx = typeof scope === "object" && "ctx" in scope ? scope.ctx : buildTenantLoadModelCtx(normalizedTenantId);
-	const globalCtx = { req: { session: null } };
-	try {
-		return await session.withTransaction(async () => fn({
-			tenantId: normalizedTenantId,
-			session,
-			ctx: {
-				tenant: tenantCtx,
-				global: globalCtx
-			},
-			db: {
-				tenant: tenantDb,
-				global: globalDb,
-				filesystem: filesystemDb
-			}
-		}), options);
-	} finally {
-		await session.endSession();
-	}
+  const normalizedTenantId = (() => {
+    if (typeof scope === "string") return scope.trim();
+    if ("tenantId" in scope) return scope.tenantId.trim();
+    return getTenantIdFromLoadModelCtx(scope.ctx);
+  })();
+  if (!normalizedTenantId) throw new Error("Tenant ID is missing");
+  const tenantDbName = getTenantDbName(normalizedTenantId);
+  const globalDbName = getGlobalDbName();
+  const filesystemDbName = getTenantFilesystemDbName(normalizedTenantId);
+  const tenantDb = await ensureMongooseConnection(tenantDbName);
+  const globalDb = await ensureMongooseConnection(globalDbName);
+  const filesystemDb = await ensureMongooseConnection(filesystemDbName);
+  const session = await tenantDb.startSession();
+  const tenantCtx = typeof scope === "object" && "ctx" in scope ? scope.ctx : buildTenantLoadModelCtx(normalizedTenantId);
+  const globalCtx = {
+    req: {
+      session: null
+    }
+  };
+  try {
+    return await session.withTransaction(async () => fn({
+      tenantId: normalizedTenantId,
+      session,
+      ctx: {
+        tenant: tenantCtx,
+        global: globalCtx
+      },
+      db: {
+        tenant: tenantDb,
+        global: globalDb,
+        filesystem: filesystemDb
+      }
+    }), options);
+  } finally {
+    await session.endSession();
+  }
 }
-//#endregion
-export { E164_PHONE_OR_EMPTY_REGEX, E164_PHONE_REGEX, LANGUAGE_CODE_REGEX, PaginationValidationError, RBNotificationPolicy, RBNotificationSchema, RBNotificationSettingsPolicy, RBNotificationSettingsSchema, RBOAuthRequestSchema, RBRtsChangeSchema, RBRtsCounterSchema, RBTenantSchema, RBTenantSubscriptionEventSchema, RBTenantSubscriptionSchema, RBUploadChunkSchema, RBUploadSessionPolicy, RBUploadSessionSchema, RBUserSchema, Schema, ZRBNotification, ZRBNotificationDigestFrequency, ZRBNotificationSettings, ZRBNotificationTopicPreference, ZRBOAuthRequest, ZRBRtsChange, ZRBRtsChangeOp, ZRBRtsCounter, ZRBTenant, ZRBTenantSubscription, ZRBTenantSubscriptionChangeDirection, ZRBTenantSubscriptionEvent, ZRBTenantSubscriptionEventSource, ZRBTenantSubscriptionIntervalUnit, ZRBTenantSubscriptionScope, ZRBTenantSubscriptionStatus, ZRBTenantSubscriptionType, ZRBUploadChunk, ZRBUploadSession, ZRBUploadSessionStatus, ZRBUser, buildAbility, buildAbilityFromSession, buildLocaleFallbackChain, buildSearchTextStage, can, createModels, ensureSearchIndex, extendMongooseSchema, extendZod, getAccessibleByQuery, getRegisteredPolicies, getTenantFilesystemDb, getTenantFilesystemDbFromCtx, getTenantFilesystemDbName, getTenantIdFromLoadModelCtx, getTenantRolesFromSessionUser, hasRegisteredPolicy, isPaginationValidationError, localizedStringField, makeZE164Phone, model, models, mongoPaginationPlugin, mongoose, omitMongooseSchemaPaths, registerPoliciesFromModules, registerPolicy, resolveLocalizedString, searchMetaProjection, withLocalizedStringFallback, withTransaction, z, zE164Phone, zI18nString, zLocalizedString };
-
-//# sourceMappingURL=index.js.map
+export {
+  E as E164_PHONE_OR_EMPTY_REGEX,
+  a2 as E164_PHONE_REGEX,
+  L as LANGUAGE_CODE_REGEX,
+  PaginationValidationError,
+  RBNotificationPolicy,
+  RBNotificationSchema,
+  RBNotificationSettingsPolicy,
+  RBNotificationSettingsSchema,
+  RBOAuthRequestSchema,
+  RBRtsChangeSchema,
+  RBRtsCounterSchema,
+  RBTenantSchema,
+  RBTenantSubscriptionEventSchema,
+  RBTenantSubscriptionSchema,
+  RBUploadChunkSchema,
+  RBUploadSessionPolicy,
+  RBUploadSessionSchema,
+  RBUserSchema,
+  Schema,
+  ZRBNotification,
+  ZRBNotificationDigestFrequency,
+  ZRBNotificationSettings,
+  ZRBNotificationTopicPreference,
+  ZRBOAuthRequest,
+  ZRBRtsChange,
+  ZRBRtsChangeOp,
+  ZRBRtsCounter,
+  ZRBTenant,
+  ZRBTenantSubscription,
+  ZRBTenantSubscriptionChangeDirection,
+  ZRBTenantSubscriptionEvent,
+  ZRBTenantSubscriptionEventSource,
+  ZRBTenantSubscriptionIntervalUnit,
+  ZRBTenantSubscriptionScope,
+  ZRBTenantSubscriptionStatus,
+  ZRBTenantSubscriptionType,
+  ZRBUploadChunk,
+  ZRBUploadSession,
+  ZRBUploadSessionStatus,
+  ZRBUser,
+  b as buildAbility,
+  a as buildAbilityFromSession,
+  b2 as buildLocaleFallbackChain,
+  buildSearchTextStage,
+  c as can,
+  createModels,
+  ensureSearchIndex,
+  extendMongooseSchema,
+  e2 as extendZod,
+  g as getAccessibleByQuery,
+  d as getRegisteredPolicies,
+  getTenantFilesystemDb,
+  getTenantFilesystemDbFromCtx,
+  getTenantFilesystemDbName,
+  getTenantIdFromLoadModelCtx,
+  e as getTenantRolesFromSessionUser,
+  hasRegisteredPolicy,
+  isPaginationValidationError,
+  localizedStringField,
+  m as makeZE164Phone,
+  model,
+  models,
+  mongoPaginationPlugin,
+  default2 as mongoose,
+  omitMongooseSchemaPaths,
+  registerPoliciesFromModules,
+  f as registerPolicy,
+  r as resolveLocalizedString,
+  searchMetaProjection,
+  withLocalizedStringFallback,
+  withTransaction,
+  z2 as z,
+  c2 as zE164Phone,
+  d2 as zI18nString,
+  f2 as zLocalizedString
+};
+//# sourceMappingURL=index.js.map