@rpcbase/db 0.123.0 → 0.124.0

package/dist/index.js

@@ -1,2524 +1,2185 @@
-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 { SUBSCRIPTION_STATUSES, SUBSCRIPTION_INTERVAL_UNITS, SUBSCRIPTION_TYPES, SUBSCRIPTION_SCOPES, SUBSCRIPTION_EVENT_TYPES, SUBSCRIPTION_CHANGE_DIRECTIONS } from "@rpcbase/billing";
-import { timingSafeEqual, createHmac } from "node:crypto";
-import { w as withLocalizedStringFallback } from "./index-DrIoUXc2.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-DrIoUXc2.js";
-import assert from "assert";
-import { getMongoUrl, getMongoDirectConnection } from "./mongo.js";
+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-DSnhyNso.js";
+import "./model.js";
+import { getMongoDirectConnection, getMongoUrl } from "./mongo.js";
 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()
+import mongoose, { Schema as Schema$1, Types, default as mongoose$1 } from "mongoose";
+import { z as z$1 } from "zod";
+import { SUBSCRIPTION_CHANGE_DIRECTIONS, SUBSCRIPTION_EVENT_TYPES, SUBSCRIPTION_INTERVAL_UNITS, SUBSCRIPTION_SCOPES, SUBSCRIPTION_STATUSES, SUBSCRIPTION_TYPES } from "@rpcbase/billing";
+import { createHmac, timingSafeEqual } from "node:crypto";
+import assert from "assert";
+//#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()
 });
-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
-  }
+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 ZRBTenant = z.object({
-  tenantId: z.string(),
-  parentTenantId: z.string().optional(),
-  name: z.string().optional()
+//#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 RBTenantSchema = new Schema$1({
-  tenantId: {
-    type: String,
-    required: true,
-    unique: true,
-    index: true
-  },
-  parentTenantId: {
-    type: String
-  },
-  name: {
-    type: String
-  }
+var RBTenantSchema = new Schema$1({
+	tenantId: {
+		type: String,
+		required: true,
+		unique: true,
+		index: true
+	},
+	parentTenantId: { type: String },
+	name: { type: String }
 });
-const ZRBTenantSubscriptionStatus = z.enum(SUBSCRIPTION_STATUSES);
-const ZRBTenantSubscriptionIntervalUnit = z.enum(SUBSCRIPTION_INTERVAL_UNITS);
-const ZRBTenantSubscriptionType = z.enum(SUBSCRIPTION_TYPES);
-const ZRBTenantSubscriptionScope = z.enum(SUBSCRIPTION_SCOPES);
-const ZRBTenantSubscriptionEventType = z.enum(SUBSCRIPTION_EVENT_TYPES);
-const ZRBTenantSubscriptionEventSource = z.enum(["admin", "system", "webhook", "user"]);
-const ZRBTenantSubscriptionChangeDirection = z.enum(SUBSCRIPTION_CHANGE_DIRECTIONS);
-const subscriptionEventBaseSchema = z.object({
-  tenantId: z.string().trim().min(1),
-  subscriptionId: z.string().trim().min(1),
-  occurredAt: z.date(),
-  effectiveAt: z.date(),
-  subscriptionType: ZRBTenantSubscriptionType,
-  parentSubscriptionId: z.string().optional(),
-  scope: ZRBTenantSubscriptionScope,
-  scopeId: z.string().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(),
-  fromPriceId: z.string().optional(),
-  toPriceId: z.string().optional(),
-  billingAnchor: z.date().optional(),
-  supersedesEventId: z.string().optional(),
-  idempotencyKey: z.string().trim().min(1),
-  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()
+//#endregion
+//#region src/models/RBTenantSubscriptionEvent.ts
+var ZRBTenantSubscriptionStatus = z$1.enum(SUBSCRIPTION_STATUSES);
+var ZRBTenantSubscriptionIntervalUnit = z$1.enum(SUBSCRIPTION_INTERVAL_UNITS);
+var ZRBTenantSubscriptionType = z$1.enum(SUBSCRIPTION_TYPES);
+var ZRBTenantSubscriptionScope = z$1.enum(SUBSCRIPTION_SCOPES);
+var ZRBTenantSubscriptionEventType = z$1.enum(SUBSCRIPTION_EVENT_TYPES);
+var ZRBTenantSubscriptionEventSource = z$1.enum([
+	"admin",
+	"system",
+	"webhook",
+	"user"
+]);
+var ZRBTenantSubscriptionChangeDirection = z$1.enum(SUBSCRIPTION_CHANGE_DIRECTIONS);
+var subscriptionEventBaseSchema = z$1.object({
+	tenantId: z$1.string().trim().min(1),
+	subscriptionId: z$1.string().trim().min(1),
+	occurredAt: z$1.date(),
+	effectiveAt: z$1.date(),
+	subscriptionType: ZRBTenantSubscriptionType,
+	parentSubscriptionId: z$1.string().optional(),
+	scope: ZRBTenantSubscriptionScope,
+	scopeId: z$1.string().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(),
+	fromPriceId: z$1.string().optional(),
+	toPriceId: z$1.string().optional(),
+	billingAnchor: z$1.date().optional(),
+	supersedesEventId: z$1.string().optional(),
+	idempotencyKey: z$1.string().trim().min(1),
+	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 subscriptionCreatedEventSchema = subscriptionEventBaseSchema.extend({
-  type: z.literal("created"),
-  toPlanKey: z.string().trim().min(1),
-  toStatus: ZRBTenantSubscriptionStatus,
-  toModules: z.array(z.string()),
-  toIntervalUnit: ZRBTenantSubscriptionIntervalUnit,
-  toIntervalCount: z.number().int().min(1),
-  billingAnchor: z.date()
+var subscriptionCreatedEventSchema = subscriptionEventBaseSchema.extend({
+	type: z$1.literal("created"),
+	toPlanKey: z$1.string().trim().min(1),
+	toStatus: ZRBTenantSubscriptionStatus,
+	toModules: z$1.array(z$1.string()),
+	toIntervalUnit: ZRBTenantSubscriptionIntervalUnit,
+	toIntervalCount: z$1.number().int().min(1),
+	billingAnchor: z$1.date()
 });
-const subscriptionPlanChangedEventSchema = subscriptionEventBaseSchema.extend({
-  type: z.literal("plan_changed"),
-  fromPlanKey: z.string().trim().min(1),
-  toPlanKey: z.string().trim().min(1),
-  fromModules: z.array(z.string()),
-  toModules: z.array(z.string()),
-  fromIntervalUnit: ZRBTenantSubscriptionIntervalUnit,
-  toIntervalUnit: ZRBTenantSubscriptionIntervalUnit,
-  fromIntervalCount: z.number().int().min(1),
-  toIntervalCount: z.number().int().min(1)
+var subscriptionPlanChangedEventSchema = subscriptionEventBaseSchema.extend({
+	type: z$1.literal("plan_changed"),
+	fromPlanKey: z$1.string().trim().min(1),
+	toPlanKey: z$1.string().trim().min(1),
+	fromModules: z$1.array(z$1.string()),
+	toModules: z$1.array(z$1.string()),
+	fromIntervalUnit: ZRBTenantSubscriptionIntervalUnit,
+	toIntervalUnit: ZRBTenantSubscriptionIntervalUnit,
+	fromIntervalCount: z$1.number().int().min(1),
+	toIntervalCount: z$1.number().int().min(1)
 });
-const subscriptionStatusChangedEventSchema = subscriptionEventBaseSchema.extend({
-  type: z.literal("status_changed"),
-  fromStatus: ZRBTenantSubscriptionStatus,
-  toStatus: ZRBTenantSubscriptionStatus
+var subscriptionStatusChangedEventSchema = subscriptionEventBaseSchema.extend({
+	type: z$1.literal("status_changed"),
+	fromStatus: ZRBTenantSubscriptionStatus,
+	toStatus: ZRBTenantSubscriptionStatus
 });
-const subscriptionResumedEventSchema = subscriptionEventBaseSchema.extend({
-  type: z.literal("resumed"),
-  fromStatus: ZRBTenantSubscriptionStatus,
-  toStatus: z.literal("active")
+var subscriptionResumedEventSchema = subscriptionEventBaseSchema.extend({
+	type: z$1.literal("resumed"),
+	fromStatus: ZRBTenantSubscriptionStatus,
+	toStatus: z$1.literal("active")
 });
-const subscriptionCanceledEventSchema = subscriptionEventBaseSchema.extend({
-  type: z.literal("canceled"),
-  fromStatus: ZRBTenantSubscriptionStatus,
-  toStatus: z.literal("canceled")
+var subscriptionCanceledEventSchema = subscriptionEventBaseSchema.extend({
+	type: z$1.literal("canceled"),
+	fromStatus: ZRBTenantSubscriptionStatus,
+	toStatus: z$1.literal("canceled")
 });
-const subscriptionRenewedEventSchema = subscriptionEventBaseSchema.extend({
-  type: z.literal("renewed"),
-  fromStatus: ZRBTenantSubscriptionStatus,
-  toStatus: ZRBTenantSubscriptionStatus
+var subscriptionRenewedEventSchema = subscriptionEventBaseSchema.extend({
+	type: z$1.literal("renewed"),
+	fromStatus: ZRBTenantSubscriptionStatus,
+	toStatus: ZRBTenantSubscriptionStatus
 });
-const ZRBTenantSubscriptionEvent = z.discriminatedUnion("type", [subscriptionCreatedEventSchema, subscriptionPlanChangedEventSchema, subscriptionStatusChangedEventSchema, subscriptionResumedEventSchema, subscriptionCanceledEventSchema, subscriptionRenewedEventSchema]).superRefine((event, ctx) => {
-  if (event.subscriptionType === "addon" && !event.parentSubscriptionId?.trim()) {
-    ctx.addIssue({
-      code: "custom",
-      message: "parentSubscriptionId is required for add-on subscriptions",
-      path: ["parentSubscriptionId"]
-    });
-  }
-  if (event.scope !== "tenant" && !event.scopeId?.trim()) {
-    ctx.addIssue({
-      code: "custom",
-      message: "scopeId is required for non-tenant subscriptions",
-      path: ["scopeId"]
-    });
-  }
+var ZRBTenantSubscriptionEvent = z$1.discriminatedUnion("type", [
+	subscriptionCreatedEventSchema,
+	subscriptionPlanChangedEventSchema,
+	subscriptionStatusChangedEventSchema,
+	subscriptionResumedEventSchema,
+	subscriptionCanceledEventSchema,
+	subscriptionRenewedEventSchema
+]).superRefine((event, ctx) => {
+	if (event.subscriptionType === "addon" && !event.parentSubscriptionId?.trim()) ctx.addIssue({
+		code: "custom",
+		message: "parentSubscriptionId is required for add-on subscriptions",
+		path: ["parentSubscriptionId"]
+	});
+	if (event.scope !== "tenant" && !event.scopeId?.trim()) ctx.addIssue({
+		code: "custom",
+		message: "scopeId is required for non-tenant subscriptions",
+		path: ["scopeId"]
+	});
 });
-const requiredForEventTypes = (...types) => function requiredForEventType() {
-  return Boolean(this.type && types.includes(this.type));
-};
-const RBTenantSubscriptionEventSchema = new Schema$1({
-  tenantId: {
-    type: String,
-    required: true,
-    index: true
-  },
-  subscriptionId: {
-    type: String,
-    required: true,
-    index: true
-  },
-  type: {
-    type: String,
-    required: true,
-    enum: ZRBTenantSubscriptionEventType.options
-  },
-  occurredAt: {
-    type: Date,
-    required: true,
-    default: Date.now
-  },
-  effectiveAt: {
-    type: Date,
-    required: true
-  },
-  subscriptionType: {
-    type: String,
-    required: true,
-    enum: ZRBTenantSubscriptionType.options
-  },
-  parentSubscriptionId: {
-    type: String,
-    required() {
-      return this.subscriptionType === "addon";
-    }
-  },
-  scope: {
-    type: String,
-    required: true,
-    enum: ZRBTenantSubscriptionScope.options
-  },
-  scopeId: {
-    type: String,
-    required() {
-      return Boolean(this.scope && this.scope !== "tenant");
-    }
-  },
-  fromPlanKey: {
-    type: String,
-    required: requiredForEventTypes("plan_changed")
-  },
-  toPlanKey: {
-    type: String,
-    required: requiredForEventTypes("created", "plan_changed")
-  },
-  fromStatus: {
-    type: String,
-    required: requiredForEventTypes("status_changed", "resumed", "canceled", "renewed"),
-    enum: ZRBTenantSubscriptionStatus.options
-  },
-  toStatus: {
-    type: String,
-    required: requiredForEventTypes("created", "status_changed", "resumed", "canceled", "renewed"),
-    enum: ZRBTenantSubscriptionStatus.options
-  },
-  fromModules: {
-    type: [String],
-    required: requiredForEventTypes("plan_changed"),
-    default: void 0
-  },
-  toModules: {
-    type: [String],
-    required: requiredForEventTypes("created", "plan_changed"),
-    default: void 0
-  },
-  fromIntervalUnit: {
-    type: String,
-    required: requiredForEventTypes("plan_changed"),
-    enum: ZRBTenantSubscriptionIntervalUnit.options
-  },
-  toIntervalUnit: {
-    type: String,
-    required: requiredForEventTypes("created", "plan_changed"),
-    enum: ZRBTenantSubscriptionIntervalUnit.options
-  },
-  fromIntervalCount: {
-    type: Number,
-    required: requiredForEventTypes("plan_changed"),
-    min: 1
-  },
-  toIntervalCount: {
-    type: Number,
-    required: requiredForEventTypes("created", "plan_changed"),
-    min: 1
-  },
-  fromPriceId: {
-    type: String
-  },
-  toPriceId: {
-    type: String
-  },
-  billingAnchor: {
-    type: Date,
-    required: requiredForEventTypes("created")
-  },
-  supersedesEventId: {
-    type: String
-  },
-  idempotencyKey: {
-    type: String,
-    required: true
-  },
-  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
-  }
+var requiredForEventTypes = (...types) => function requiredForEventType() {
+	return Boolean(this.type && types.includes(this.type));
+};
+var RBTenantSubscriptionEventSchema = new Schema$1({
+	tenantId: {
+		type: String,
+		required: true,
+		index: true
+	},
+	subscriptionId: {
+		type: String,
+		required: true,
+		index: true
+	},
+	type: {
+		type: String,
+		required: true,
+		enum: ZRBTenantSubscriptionEventType.options
+	},
+	occurredAt: {
+		type: Date,
+		required: true,
+		default: Date.now
+	},
+	effectiveAt: {
+		type: Date,
+		required: true
+	},
+	subscriptionType: {
+		type: String,
+		required: true,
+		enum: ZRBTenantSubscriptionType.options
+	},
+	parentSubscriptionId: {
+		type: String,
+		required() {
+			return this.subscriptionType === "addon";
+		}
+	},
+	scope: {
+		type: String,
+		required: true,
+		enum: ZRBTenantSubscriptionScope.options
+	},
+	scopeId: {
+		type: String,
+		required() {
+			return Boolean(this.scope && this.scope !== "tenant");
+		}
+	},
+	fromPlanKey: {
+		type: String,
+		required: requiredForEventTypes("plan_changed")
+	},
+	toPlanKey: {
+		type: String,
+		required: requiredForEventTypes("created", "plan_changed")
+	},
+	fromStatus: {
+		type: String,
+		required: requiredForEventTypes("status_changed", "resumed", "canceled", "renewed"),
+		enum: ZRBTenantSubscriptionStatus.options
+	},
+	toStatus: {
+		type: String,
+		required: requiredForEventTypes("created", "status_changed", "resumed", "canceled", "renewed"),
+		enum: ZRBTenantSubscriptionStatus.options
+	},
+	fromModules: {
+		type: [String],
+		required: requiredForEventTypes("plan_changed"),
+		default: void 0
+	},
+	toModules: {
+		type: [String],
+		required: requiredForEventTypes("created", "plan_changed"),
+		default: void 0
+	},
+	fromIntervalUnit: {
+		type: String,
+		required: requiredForEventTypes("plan_changed"),
+		enum: ZRBTenantSubscriptionIntervalUnit.options
+	},
+	toIntervalUnit: {
+		type: String,
+		required: requiredForEventTypes("created", "plan_changed"),
+		enum: ZRBTenantSubscriptionIntervalUnit.options
+	},
+	fromIntervalCount: {
+		type: Number,
+		required: requiredForEventTypes("plan_changed"),
+		min: 1
+	},
+	toIntervalCount: {
+		type: Number,
+		required: requiredForEventTypes("created", "plan_changed"),
+		min: 1
+	},
+	fromPriceId: { type: String },
+	toPriceId: { type: String },
+	billingAnchor: {
+		type: Date,
+		required: requiredForEventTypes("created")
+	},
+	supersedesEventId: { type: String },
+	idempotencyKey: {
+		type: String,
+		required: true
+	},
+	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,
-  effectiveAt: 1,
-  occurredAt: 1
+	tenantId: 1,
+	subscriptionId: 1,
+	effectiveAt: 1,
+	occurredAt: 1
 });
 RBTenantSubscriptionEventSchema.index({
-  provider: 1,
-  providerEventId: 1
+	provider: 1,
+	providerEventId: 1
 }, {
-  unique: true,
-  partialFilterExpression: {
-    provider: {
-      $type: "string"
-    },
-    providerEventId: {
-      $type: "string"
-    }
-  }
+	unique: true,
+	partialFilterExpression: {
+		provider: { $type: "string" },
+		providerEventId: { $type: "string" }
+	}
 });
 RBTenantSubscriptionEventSchema.index({
-  tenantId: 1,
-  idempotencyKey: 1
-}, {
-  unique: true
+	tenantId: 1,
+	idempotencyKey: 1
+}, { unique: true });
+//#endregion
+//#region src/models/RBTenantSubscriptionProjection.ts
+var ZRBTenantSubscriptionProjection = z$1.object({
+	tenantId: z$1.string(),
+	subscriptionId: z$1.string(),
+	type: ZRBTenantSubscriptionType,
+	parentSubscriptionId: z$1.string().optional(),
+	scope: ZRBTenantSubscriptionScope,
+	scopeId: z$1.string().optional(),
+	planKey: z$1.string(),
+	priceId: z$1.string().optional(),
+	status: ZRBTenantSubscriptionStatus,
+	intervalUnit: ZRBTenantSubscriptionIntervalUnit,
+	intervalCount: z$1.number().int().min(1),
+	modules: z$1.array(z$1.string()),
+	billingAnchor: z$1.date(),
+	currentPeriodStart: z$1.date(),
+	currentPeriodEnd: z$1.date(),
+	cancelAtPeriodEnd: z$1.boolean(),
+	cancelAt: z$1.date().optional(),
+	canceledAt: z$1.date().optional(),
+	scheduledPlanKey: z$1.string().optional(),
+	scheduledPlanEffectiveAt: z$1.date().optional(),
+	provider: z$1.string().optional(),
+	latestEventId: z$1.string(),
+	latestEventAt: z$1.date(),
+	projectedAt: z$1.date()
 });
-const ZRBTenantSubscriptionProjection = z.object({
-  tenantId: z.string(),
-  subscriptionId: z.string(),
-  type: ZRBTenantSubscriptionType,
-  parentSubscriptionId: z.string().optional(),
-  scope: ZRBTenantSubscriptionScope,
-  scopeId: z.string().optional(),
-  planKey: z.string(),
-  priceId: z.string().optional(),
-  status: ZRBTenantSubscriptionStatus,
-  intervalUnit: ZRBTenantSubscriptionIntervalUnit,
-  intervalCount: z.number().int().min(1),
-  modules: z.array(z.string()),
-  billingAnchor: z.date(),
-  currentPeriodStart: z.date(),
-  currentPeriodEnd: z.date(),
-  cancelAtPeriodEnd: z.boolean(),
-  cancelAt: z.date().optional(),
-  canceledAt: z.date().optional(),
-  scheduledPlanKey: z.string().optional(),
-  scheduledPlanEffectiveAt: z.date().optional(),
-  provider: z.string().optional(),
-  latestEventId: z.string(),
-  latestEventAt: z.date(),
-  projectedAt: z.date()
-});
-const RBTenantSubscriptionProjectionSchema = new Schema$1({
-  tenantId: {
-    type: String,
-    required: true,
-    index: true
-  },
-  subscriptionId: {
-    type: String,
-    required: true
-  },
-  type: {
-    type: String,
-    required: true,
-    enum: ZRBTenantSubscriptionType.options
-  },
-  parentSubscriptionId: {
-    type: String
-  },
-  scope: {
-    type: String,
-    required: true,
-    enum: ZRBTenantSubscriptionScope.options
-  },
-  scopeId: {
-    type: String
-  },
-  planKey: {
-    type: String,
-    required: true
-  },
-  priceId: {
-    type: String
-  },
-  status: {
-    type: String,
-    required: true,
-    enum: ZRBTenantSubscriptionStatus.options
-  },
-  intervalUnit: {
-    type: String,
-    required: true,
-    enum: ZRBTenantSubscriptionIntervalUnit.options
-  },
-  intervalCount: {
-    type: Number,
-    required: true,
-    min: 1
-  },
-  modules: {
-    type: [String],
-    required: true,
-    default: []
-  },
-  billingAnchor: {
-    type: Date,
-    required: true
-  },
-  currentPeriodStart: {
-    type: Date,
-    required: true
-  },
-  currentPeriodEnd: {
-    type: Date,
-    required: true
-  },
-  cancelAtPeriodEnd: {
-    type: Boolean,
-    required: true,
-    default: false
-  },
-  cancelAt: {
-    type: Date
-  },
-  canceledAt: {
-    type: Date
-  },
-  scheduledPlanKey: {
-    type: String
-  },
-  scheduledPlanEffectiveAt: {
-    type: Date
-  },
-  provider: {
-    type: String
-  },
-  latestEventId: {
-    type: String,
-    required: true
-  },
-  latestEventAt: {
-    type: Date,
-    required: true
-  },
-  projectedAt: {
-    type: Date,
-    required: true
-  }
+var RBTenantSubscriptionProjectionSchema = new Schema$1({
+	tenantId: {
+		type: String,
+		required: true,
+		index: true
+	},
+	subscriptionId: {
+		type: String,
+		required: true
+	},
+	type: {
+		type: String,
+		required: true,
+		enum: ZRBTenantSubscriptionType.options
+	},
+	parentSubscriptionId: { type: String },
+	scope: {
+		type: String,
+		required: true,
+		enum: ZRBTenantSubscriptionScope.options
+	},
+	scopeId: { type: String },
+	planKey: {
+		type: String,
+		required: true
+	},
+	priceId: { type: String },
+	status: {
+		type: String,
+		required: true,
+		enum: ZRBTenantSubscriptionStatus.options
+	},
+	intervalUnit: {
+		type: String,
+		required: true,
+		enum: ZRBTenantSubscriptionIntervalUnit.options
+	},
+	intervalCount: {
+		type: Number,
+		required: true,
+		min: 1
+	},
+	modules: {
+		type: [String],
+		required: true,
+		default: []
+	},
+	billingAnchor: {
+		type: Date,
+		required: true
+	},
+	currentPeriodStart: {
+		type: Date,
+		required: true
+	},
+	currentPeriodEnd: {
+		type: Date,
+		required: true
+	},
+	cancelAtPeriodEnd: {
+		type: Boolean,
+		required: true,
+		default: false
+	},
+	cancelAt: { type: Date },
+	canceledAt: { type: Date },
+	scheduledPlanKey: { type: String },
+	scheduledPlanEffectiveAt: { type: Date },
+	provider: { type: String },
+	latestEventId: {
+		type: String,
+		required: true
+	},
+	latestEventAt: {
+		type: Date,
+		required: true
+	},
+	projectedAt: {
+		type: Date,
+		required: true
+	}
 });
 RBTenantSubscriptionProjectionSchema.index({
-  tenantId: 1,
-  subscriptionId: 1
-}, {
-  unique: true
-});
+	tenantId: 1,
+	subscriptionId: 1
+}, { unique: true });
 RBTenantSubscriptionProjectionSchema.index({
-  tenantId: 1,
-  scope: 1,
-  scopeId: 1
+	tenantId: 1,
+	scope: 1,
+	scopeId: 1
 });
-const ZRBRtsCounter = z.object({
-  _id: z.string(),
-  seq: z.number().int().min(0)
+//#endregion
+//#region src/models/RBRtsCounter.ts
+var ZRBRtsCounter = z$1.object({
+	_id: z$1.string(),
+	seq: z$1.number().int().min(0)
 });
-const RBRtsCounterSchema = new Schema$1({
-  _id: {
-    type: String,
-    required: true
-  },
-  seq: {
-    type: Number,
-    required: true,
-    default: 0
-  }
-}, {
-  versionKey: false
-});
-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()
-});
-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
+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()
 });
-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
-});
-RBUploadChunkSchema.index({
-  uploadId: 1,
-  index: 1
-}, {
-  unique: true
+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()
 });
+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({
-  expiresAt: 1
-}, {
-  expireAfterSeconds: 0
-});
-const ZStringMap$1 = z.record(z.string(), z.string());
-const ZRBNotificationPlatformPayload = z.object({
-  webpush: z.record(z.string(), z.unknown()).optional(),
-  fcmOptions: z.record(z.string(), z.unknown()).optional(),
-  android: z.record(z.string(), z.unknown()).optional(),
-  apns: z.record(z.string(), z.unknown()).optional()
+	uploadId: 1,
+	index: 1
+}, { unique: true });
+RBUploadChunkSchema.index({ expiresAt: 1 }, { expireAfterSeconds: 0 });
+//#endregion
+//#region src/models/RBNotification.ts
+var ZStringMap$1 = z$1.record(z$1.string(), z$1.string());
+var ZRBNotificationPlatformPayload = z$1.object({
+	webpush: z$1.record(z$1.string(), z$1.unknown()).optional(),
+	fcmOptions: z$1.record(z$1.string(), z$1.unknown()).optional(),
+	android: z$1.record(z$1.string(), z$1.unknown()).optional(),
+	apns: z$1.record(z$1.string(), z$1.unknown()).optional()
 }).passthrough();
-const ZRBNotification = z.object({
-  userId: z.string(),
-  topic: z.string().optional(),
-  tag: z.string().optional(),
-  deliveryId: z.string().optional(),
-  title: z.string(),
-  body: z.string().optional(),
-  image: z.string().optional(),
-  data: ZStringMap$1.optional(),
-  platform: ZRBNotificationPlatformPayload.optional(),
-  drawerActive: z.boolean().optional(),
-  createdAt: z.date(),
-  seenAt: z.date().optional(),
-  readAt: z.date().optional(),
-  archivedAt: z.date().optional()
-});
-const TTL_90_DAYS_S$1 = 60 * 60 * 24 * 90;
-const RBNotificationSchema = new Schema$1({
-  userId: {
-    type: String,
-    required: true,
-    index: true
-  },
-  topic: {
-    type: String,
-    required: false,
-    index: true
-  },
-  tag: {
-    type: String,
-    required: false
-  },
-  deliveryId: {
-    type: String,
-    required: false
-  },
-  title: {
-    type: String,
-    required: true
-  },
-  body: {
-    type: String,
-    required: false
-  },
-  image: {
-    type: String,
-    required: false
-  },
-  data: {
-    type: Schema$1.Types.Mixed,
-    required: false
-  },
-  platform: {
-    type: Schema$1.Types.Mixed,
-    required: false
-  },
-  drawerActive: {
-    type: Boolean,
-    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
-  }
-}, {
-  versionKey: false
+var ZRBNotification = z$1.object({
+	userId: z$1.string(),
+	topic: z$1.string().optional(),
+	tag: z$1.string().optional(),
+	deliveryId: z$1.string().optional(),
+	title: z$1.string(),
+	body: z$1.string().optional(),
+	image: z$1.string().optional(),
+	data: ZStringMap$1.optional(),
+	platform: ZRBNotificationPlatformPayload.optional(),
+	drawerActive: z$1.boolean().optional(),
+	createdAt: z$1.date(),
+	seenAt: z$1.date().optional(),
+	readAt: z$1.date().optional(),
+	archivedAt: z$1.date().optional()
 });
+var TTL_90_DAYS_S$1 = 3600 * 24 * 90;
+var RBNotificationSchema = new Schema$1({
+	userId: {
+		type: String,
+		required: true,
+		index: true
+	},
+	topic: {
+		type: String,
+		required: false,
+		index: true
+	},
+	tag: {
+		type: String,
+		required: false
+	},
+	deliveryId: {
+		type: String,
+		required: false
+	},
+	title: {
+		type: String,
+		required: true
+	},
+	body: {
+		type: String,
+		required: false
+	},
+	image: {
+		type: String,
+		required: false
+	},
+	data: {
+		type: Schema$1.Types.Mixed,
+		required: false
+	},
+	platform: {
+		type: Schema$1.Types.Mixed,
+		required: false
+	},
+	drawerActive: {
+		type: Boolean,
+		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
+	}
+}, { 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({
-  userId: 1,
-  tag: 1
+	userId: 1,
+	tag: 1
 }, {
-  unique: true,
-  partialFilterExpression: {
-    tag: {
-      $exists: true
-    },
-    drawerActive: true
-  }
+	unique: true,
+	partialFilterExpression: {
+		tag: { $exists: true },
+		drawerActive: true
+	}
 });
-RBNotificationSchema.index({
-  archivedAt: 1
-}, {
-  expireAfterSeconds: TTL_90_DAYS_S$1
-});
-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 ZStringMap = z.record(z.string(), z.string());
-const ZRBNotificationDelivery = z.object({
-  userId: z.string(),
-  notificationId: z.string().optional(),
-  deliveryId: z.string(),
-  topic: z.string().optional(),
-  tag: z.string().optional(),
-  title: z.string(),
-  body: z.string().optional(),
-  image: z.string().optional(),
-  data: ZStringMap.optional(),
-  platform: ZRBNotificationPlatformPayload.optional(),
-  createdAt: z.date()
-});
-const TTL_90_DAYS_S = 60 * 60 * 24 * 90;
-const RBNotificationDeliverySchema = new Schema$1({
-  userId: {
-    type: String,
-    required: true,
-    index: true
-  },
-  notificationId: {
-    type: String,
-    required: false
-  },
-  deliveryId: {
-    type: String,
-    required: true,
-    unique: true
-  },
-  topic: {
-    type: String,
-    required: false
-  },
-  tag: {
-    type: String,
-    required: false
-  },
-  title: {
-    type: String,
-    required: true
-  },
-  body: {
-    type: String,
-    required: false
-  },
-  image: {
-    type: String,
-    required: false
-  },
-  data: {
-    type: Schema$1.Types.Mixed,
-    required: false
-  },
-  platform: {
-    type: Schema$1.Types.Mixed,
-    required: false
-  },
-  createdAt: {
-    type: Date,
-    required: true,
-    default: Date.now
-  }
-}, {
-  versionKey: false
-});
-RBNotificationDeliverySchema.index({
-  userId: 1,
-  createdAt: -1
+RBNotificationSchema.index({ archivedAt: 1 }, { expireAfterSeconds: TTL_90_DAYS_S$1 });
+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/RBNotificationDelivery.ts
+var ZStringMap = z$1.record(z$1.string(), z$1.string());
+var ZRBNotificationDelivery = z$1.object({
+	userId: z$1.string(),
+	notificationId: z$1.string().optional(),
+	deliveryId: z$1.string(),
+	topic: z$1.string().optional(),
+	tag: z$1.string().optional(),
+	title: z$1.string(),
+	body: z$1.string().optional(),
+	image: z$1.string().optional(),
+	data: ZStringMap.optional(),
+	platform: ZRBNotificationPlatformPayload.optional(),
+	createdAt: z$1.date()
 });
+var TTL_90_DAYS_S = 3600 * 24 * 90;
+var RBNotificationDeliverySchema = new Schema$1({
+	userId: {
+		type: String,
+		required: true,
+		index: true
+	},
+	notificationId: {
+		type: String,
+		required: false
+	},
+	deliveryId: {
+		type: String,
+		required: true,
+		unique: true
+	},
+	topic: {
+		type: String,
+		required: false
+	},
+	tag: {
+		type: String,
+		required: false
+	},
+	title: {
+		type: String,
+		required: true
+	},
+	body: {
+		type: String,
+		required: false
+	},
+	image: {
+		type: String,
+		required: false
+	},
+	data: {
+		type: Schema$1.Types.Mixed,
+		required: false
+	},
+	platform: {
+		type: Schema$1.Types.Mixed,
+		required: false
+	},
+	createdAt: {
+		type: Date,
+		required: true,
+		default: Date.now
+	}
+}, { versionKey: false });
 RBNotificationDeliverySchema.index({
-  createdAt: 1
-}, {
-  expireAfterSeconds: TTL_90_DAYS_S
-});
-const RBNotificationDeliveryPolicy = {
-  subject: "RBNotificationDelivery",
-  define: (builder, ctx) => {
-    if (!ctx.userId) return;
-    builder.can("create", "RBNotificationDelivery");
-    builder.can("read", "RBNotificationDelivery", {
-      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()
+	userId: 1,
+	createdAt: -1
 });
-const ZRBNotificationSettings = z.object({
-  userId: z.string(),
-  digestFrequency: ZRBNotificationDigestFrequency,
-  topicPreferences: z.array(ZRBNotificationTopicPreference).optional(),
-  lastDigestSentAt: z.date().optional()
+RBNotificationDeliverySchema.index({ createdAt: 1 }, { expireAfterSeconds: TTL_90_DAYS_S });
+var RBNotificationDeliveryPolicy = {
+	subject: "RBNotificationDelivery",
+	define: (builder, ctx) => {
+		if (!ctx.userId) return;
+		builder.can("create", "RBNotificationDelivery");
+		builder.can("read", "RBNotificationDelivery", { 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()
 });
-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
-  }
-}, {
-  _id: false
+var ZRBNotificationSettings = z$1.object({
+	userId: z$1.string(),
+	digestFrequency: ZRBNotificationDigestFrequency,
+	topicPreferences: z$1.array(ZRBNotificationTopicPreference).optional(),
+	lastDigestSentAt: z$1.date().optional()
 });
-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
-  }
+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
+	}
 }, {
-  versionKey: false,
-  timestamps: true
+	versionKey: false,
+	timestamps: true
 });
+RBNotificationSettingsSchema.index({ userId: 1 }, { unique: true });
 RBNotificationSettingsSchema.index({
-  userId: 1
-}, {
-  unique: true
+	userId: 1,
+	"topicPreferences.topic": 1
 });
-RBNotificationSettingsSchema.index({
-  userId: 1,
-  "topicPreferences.topic": 1
+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()
 });
-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()
+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({
+	RBNotificationDeliveryPolicy: () => RBNotificationDeliveryPolicy,
+	RBNotificationDeliverySchema: () => RBNotificationDeliverySchema,
+	RBNotificationPolicy: () => RBNotificationPolicy,
+	RBNotificationSchema: () => RBNotificationSchema,
+	RBNotificationSettingsPolicy: () => RBNotificationSettingsPolicy,
+	RBNotificationSettingsSchema: () => RBNotificationSettingsSchema,
+	RBOAuthRequestSchema: () => RBOAuthRequestSchema,
+	RBRtsChangeSchema: () => RBRtsChangeSchema,
+	RBRtsCounterSchema: () => RBRtsCounterSchema,
+	RBTenantSchema: () => RBTenantSchema,
+	RBTenantSubscriptionEventSchema: () => RBTenantSubscriptionEventSchema,
+	RBTenantSubscriptionProjectionSchema: () => RBTenantSubscriptionProjectionSchema,
+	RBUploadChunkSchema: () => RBUploadChunkSchema,
+	RBUploadSessionPolicy: () => RBUploadSessionPolicy,
+	RBUploadSessionSchema: () => RBUploadSessionSchema,
+	RBUserSchema: () => RBUserSchema,
+	ZRBNotification: () => ZRBNotification,
+	ZRBNotificationDelivery: () => ZRBNotificationDelivery,
+	ZRBNotificationDigestFrequency: () => ZRBNotificationDigestFrequency,
+	ZRBNotificationPlatformPayload: () => ZRBNotificationPlatformPayload,
+	ZRBNotificationSettings: () => ZRBNotificationSettings,
+	ZRBNotificationTopicPreference: () => ZRBNotificationTopicPreference,
+	ZRBOAuthRequest: () => ZRBOAuthRequest,
+	ZRBRtsChange: () => ZRBRtsChange,
+	ZRBRtsChangeOp: () => ZRBRtsChangeOp,
+	ZRBRtsCounter: () => ZRBRtsCounter,
+	ZRBTenant: () => ZRBTenant,
+	ZRBTenantSubscriptionChangeDirection: () => ZRBTenantSubscriptionChangeDirection,
+	ZRBTenantSubscriptionEvent: () => ZRBTenantSubscriptionEvent,
+	ZRBTenantSubscriptionEventSource: () => ZRBTenantSubscriptionEventSource,
+	ZRBTenantSubscriptionEventType: () => ZRBTenantSubscriptionEventType,
+	ZRBTenantSubscriptionIntervalUnit: () => ZRBTenantSubscriptionIntervalUnit,
+	ZRBTenantSubscriptionProjection: () => ZRBTenantSubscriptionProjection,
+	ZRBTenantSubscriptionScope: () => ZRBTenantSubscriptionScope,
+	ZRBTenantSubscriptionStatus: () => ZRBTenantSubscriptionStatus,
+	ZRBTenantSubscriptionType: () => ZRBTenantSubscriptionType,
+	ZRBUploadChunk: () => ZRBUploadChunk,
+	ZRBUploadSession: () => ZRBUploadSession,
+	ZRBUploadSessionStatus: () => ZRBUploadSessionStatus,
+	ZRBUser: () => ZRBUser
 });
-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
-});
-RBOAuthRequestSchema.index({
-  expiresAt: 1
-}, {
-  expireAfterSeconds: 0
-});
-const frameworkSchemas = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  RBNotificationDeliveryPolicy,
-  RBNotificationDeliverySchema,
-  RBNotificationPolicy,
-  RBNotificationSchema,
-  RBNotificationSettingsPolicy,
-  RBNotificationSettingsSchema,
-  RBOAuthRequestSchema,
-  RBRtsChangeSchema,
-  RBRtsCounterSchema,
-  RBTenantSchema,
-  RBTenantSubscriptionEventSchema,
-  RBTenantSubscriptionProjectionSchema,
-  RBUploadChunkSchema,
-  RBUploadSessionPolicy,
-  RBUploadSessionSchema,
-  RBUserSchema,
-  ZRBNotification,
-  ZRBNotificationDelivery,
-  ZRBNotificationDigestFrequency,
-  ZRBNotificationPlatformPayload,
-  ZRBNotificationSettings,
-  ZRBNotificationTopicPreference,
-  ZRBOAuthRequest,
-  ZRBRtsChange,
-  ZRBRtsChangeOp,
-  ZRBRtsCounter,
-  ZRBTenant,
-  ZRBTenantSubscriptionChangeDirection,
-  ZRBTenantSubscriptionEvent,
-  ZRBTenantSubscriptionEventSource,
-  ZRBTenantSubscriptionEventType,
-  ZRBTenantSubscriptionIntervalUnit,
-  ZRBTenantSubscriptionProjection,
-  ZRBTenantSubscriptionScope,
-  ZRBTenantSubscriptionStatus,
-  ZRBTenantSubscriptionType,
-  ZRBUploadChunk,
-  ZRBUploadSession,
-  ZRBUploadSessionStatus,
-  ZRBUser
-}, Symbol.toStringTag, { value: "Module" }));
+//#endregion
+//#region src/mongoose/extendMongooseSchema.ts
 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)
+	};
 }
-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, options = {}) => {
-  if (!spec || typeof spec !== "object") throw new PaginationValidationError("Invalid PaginationSpec");
-  const limit = normalizeLimit(spec.limit, normalizeMaxLimit(options.maxLimit));
-  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 normalizeMaxLimit = (maxLimit) => {
-  if (maxLimit === void 0) return PAGINATION_LIMIT_MAX;
-  if (!Number.isSafeInteger(maxLimit) || maxLimit <= 0) {
-    throw new PaginationValidationError("Invalid pagination max limit");
-  }
-  return maxLimit;
-};
-const normalizeLimit = (limit, maxLimit) => {
-  if (typeof limit !== "number" || !Number.isFinite(limit) || !Number.isInteger(limit) || limit <= 0) {
-    throw new PaginationValidationError("Invalid pagination limit");
-  }
-  if (limit > maxLimit) {
-    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, {
-    maxLimit: options.maxLimit
-  });
-  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, {
-    maxLimit: options.maxLimit
-  });
-  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, {
-    maxLimit: options.cursor.maxLimit
-  });
-  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 (options.includeCursors !== false && hasPrevPage) {
-    pageInfo.prevCursor = encodePaginationCursor(compiled.spec, nodes[0], options.cursor);
-  }
-  if (options.includeCursors !== false && 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,
-    includeCursors: options.includeCursors
-  });
-};
-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,
-      includeCursors: options?.includeCursors ?? pluginOptions?.includeCursors
-    });
-  };
-};
-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 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,
-      directConnection: getMongoDirectConnection()
-    });
-  }
-  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
-      }
-    }
-  }
+//#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 = /* @__PURE__ */ new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+var PAGINATION_LIMIT_MAX = 128;
+var normalizePaginationSpec = (spec, options = {}) => {
+	if (!spec || typeof spec !== "object") throw new PaginationValidationError("Invalid PaginationSpec");
+	const limit = normalizeLimit(spec.limit, normalizeMaxLimit(options.maxLimit));
+	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 normalizeMaxLimit = (maxLimit) => {
+	if (maxLimit === void 0) return PAGINATION_LIMIT_MAX;
+	if (!Number.isSafeInteger(maxLimit) || maxLimit <= 0) throw new PaginationValidationError("Invalid pagination max limit");
+	return maxLimit;
+};
+var normalizeLimit = (limit, maxLimit) => {
+	if (typeof limit !== "number" || !Number.isFinite(limit) || !Number.isInteger(limit) || limit <= 0) throw new PaginationValidationError("Invalid pagination limit");
+	if (limit > maxLimit) 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, { maxLimit: options.maxLimit });
+	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, { maxLimit: options.maxLimit });
+	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, { maxLimit: options.cursor.maxLimit });
+	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 (options.includeCursors !== false && hasPrevPage) pageInfo.prevCursor = encodePaginationCursor(compiled.spec, nodes[0], options.cursor);
+	if (options.includeCursors !== false && 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,
+		includeCursors: options.includeCursors
+	});
+};
+//#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,
+			includeCursors: options?.includeCursors ?? pluginOptions?.includeCursors
+		});
+	};
+};
+//#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/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,
+			directConnection: getMongoDirectConnection()
+		});
+	}
+	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 = /* @__PURE__ */ 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 = /* @__PURE__ */ 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
+	};
 });
+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();
+	}
 }
-const getTransactionSession = (transaction) => {
-  if (!transaction || typeof transaction !== "object" || !("session" in transaction)) return void 0;
-  return transaction.session;
-};
-const toSubscriptionEvent = (document) => {
-  const parsed = ZRBTenantSubscriptionEvent.parse(document);
-  if (!document._id) throw new Error("Persisted subscription event is missing its id");
-  return {
-    ...parsed,
-    id: String(document._id)
-  };
-};
-const getExistingEventQuery = (event, tenantId) => ({
-  tenantId,
-  idempotencyKey: event.idempotencyKey
+//#endregion
+//#region src/billingStorage.ts
+var getTransactionSession = (transaction) => {
+	if (!transaction || typeof transaction !== "object" || !("session" in transaction)) return void 0;
+	return transaction.session;
+};
+var toSubscriptionEvent = (document) => {
+	const parsed = ZRBTenantSubscriptionEvent.parse(document);
+	if (!document._id) throw new Error("Persisted subscription event is missing its id");
+	return {
+		...parsed,
+		id: String(document._id)
+	};
+};
+var getExistingEventQuery = (event, tenantId) => ({
+	tenantId,
+	idempotencyKey: event.idempotencyKey
 });
-const isDuplicateKeyError = (error) => Boolean(error && typeof error === "object" && "code" in error && error.code === 11e3);
-const toProjectionDocument = (projection) => ({
-  tenantId: projection.tenantId,
-  subscriptionId: projection.subscriptionId,
-  type: projection.type,
-  parentSubscriptionId: projection.parentSubscriptionId ?? void 0,
-  scope: projection.scope,
-  scopeId: projection.scopeId ?? void 0,
-  planKey: projection.planKey,
-  priceId: projection.priceId ?? void 0,
-  status: projection.status,
-  intervalUnit: projection.intervalUnit,
-  intervalCount: projection.intervalCount,
-  modules: projection.modules,
-  billingAnchor: projection.billingAnchor,
-  currentPeriodStart: projection.currentPeriodStart,
-  currentPeriodEnd: projection.currentPeriodEnd,
-  cancelAtPeriodEnd: projection.cancelAtPeriodEnd,
-  cancelAt: projection.cancelAt ?? void 0,
-  canceledAt: projection.canceledAt ?? void 0,
-  scheduledPlanKey: projection.scheduledPlan?.planKey,
-  scheduledPlanEffectiveAt: projection.scheduledPlan?.effectiveAt,
-  provider: projection.provider ?? void 0,
-  latestEventId: projection.latestEventId,
-  latestEventAt: projection.latestEventAt,
-  projectedAt: projection.projectedAt
+var isDuplicateKeyError = (error) => Boolean(error && typeof error === "object" && "code" in error && error.code === 11e3);
+var toProjectionDocument = (projection) => ({
+	tenantId: projection.tenantId,
+	subscriptionId: projection.subscriptionId,
+	type: projection.type,
+	parentSubscriptionId: projection.parentSubscriptionId ?? void 0,
+	scope: projection.scope,
+	scopeId: projection.scopeId ?? void 0,
+	planKey: projection.planKey,
+	priceId: projection.priceId ?? void 0,
+	status: projection.status,
+	intervalUnit: projection.intervalUnit,
+	intervalCount: projection.intervalCount,
+	modules: projection.modules,
+	billingAnchor: projection.billingAnchor,
+	currentPeriodStart: projection.currentPeriodStart,
+	currentPeriodEnd: projection.currentPeriodEnd,
+	cancelAtPeriodEnd: projection.cancelAtPeriodEnd,
+	cancelAt: projection.cancelAt ?? void 0,
+	canceledAt: projection.canceledAt ?? void 0,
+	scheduledPlanKey: projection.scheduledPlan?.planKey,
+	scheduledPlanEffectiveAt: projection.scheduledPlan?.effectiveAt,
+	provider: projection.provider ?? void 0,
+	latestEventId: projection.latestEventId,
+	latestEventAt: projection.latestEventAt,
+	projectedAt: projection.projectedAt
 });
-const createTenantBillingStorage = (params) => {
-  const findExistingEvent = async (query, transaction) => {
-    const EventModel = await models.get("RBTenantSubscriptionEvent", params.ctx);
-    const request = EventModel.findOne(query);
-    const session = getTransactionSession(transaction);
-    if (session) request.session(session);
-    const document = await request.lean();
-    return document ? toSubscriptionEvent(document) : null;
-  };
-  return {
-    runInTransaction: (operation) => withTransaction({
-      ctx: params.ctx
-    }, ({
-      session
-    }) => operation({
-      session
-    })),
-    createEvent: async (event, transaction) => {
-      if (event.tenantId !== params.tenantId) {
-        throw new Error("Billing event tenantId does not match the storage tenant");
-      }
-      const existingQuery = getExistingEventQuery(event, params.tenantId);
-      const existing = await findExistingEvent(existingQuery, transaction);
-      if (existing) return existing;
-      const EventModel = await models.get("RBTenantSubscriptionEvent", params.ctx);
-      const eventDocument = ZRBTenantSubscriptionEvent.parse(event);
-      const session = getTransactionSession(transaction);
-      try {
-        const documents = await EventModel.create([eventDocument], session ? {
-          session
-        } : void 0);
-        const document = documents[0]?.toObject();
-        if (!document) throw new Error("Subscription event was not persisted");
-        return toSubscriptionEvent(document);
-      } catch (error) {
-        if (!isDuplicateKeyError(error)) throw error;
-        const duplicate = await findExistingEvent(existingQuery, transaction);
-        if (!duplicate) throw error;
-        return duplicate;
-      }
-    },
-    listEvents: async (tenantId, subscriptionId, transaction) => {
-      if (tenantId !== params.tenantId) throw new Error("Billing storage tenant mismatch");
-      const EventModel = await models.get("RBTenantSubscriptionEvent", params.ctx);
-      const request = EventModel.find({
-        tenantId,
-        subscriptionId
-      }).sort({
-        effectiveAt: 1,
-        occurredAt: 1,
-        _id: 1
-      });
-      const session = getTransactionSession(transaction);
-      if (session) request.session(session);
-      const documents = await request.lean();
-      return documents.map(toSubscriptionEvent);
-    },
-    upsertProjection: async (projection, transaction) => {
-      if (projection.tenantId !== params.tenantId) throw new Error("Billing projection tenant mismatch");
-      const ProjectionModel = await models.get("RBTenantSubscriptionProjection", params.ctx);
-      const session = getTransactionSession(transaction);
-      await ProjectionModel.replaceOne({
-        tenantId: params.tenantId,
-        subscriptionId: projection.subscriptionId
-      }, toProjectionDocument(projection), {
-        upsert: true,
-        runValidators: true,
-        ...session ? {
-          session
-        } : {}
-      });
-    }
-  };
-};
-export {
-  E as E164_PHONE_OR_EMPTY_REGEX,
-  a2 as E164_PHONE_REGEX,
-  L as LANGUAGE_CODE_REGEX,
-  PaginationValidationError,
-  RBNotificationDeliveryPolicy,
-  RBNotificationDeliverySchema,
-  RBNotificationPolicy,
-  RBNotificationSchema,
-  RBNotificationSettingsPolicy,
-  RBNotificationSettingsSchema,
-  RBOAuthRequestSchema,
-  RBRtsChangeSchema,
-  RBRtsCounterSchema,
-  RBTenantSchema,
-  RBTenantSubscriptionEventSchema,
-  RBTenantSubscriptionProjectionSchema,
-  RBUploadChunkSchema,
-  RBUploadSessionPolicy,
-  RBUploadSessionSchema,
-  RBUserSchema,
-  Schema,
-  ZRBNotification,
-  ZRBNotificationDelivery,
-  ZRBNotificationDigestFrequency,
-  ZRBNotificationPlatformPayload,
-  ZRBNotificationSettings,
-  ZRBNotificationTopicPreference,
-  ZRBOAuthRequest,
-  ZRBRtsChange,
-  ZRBRtsChangeOp,
-  ZRBRtsCounter,
-  ZRBTenant,
-  ZRBTenantSubscriptionChangeDirection,
-  ZRBTenantSubscriptionEvent,
-  ZRBTenantSubscriptionEventSource,
-  ZRBTenantSubscriptionEventType,
-  ZRBTenantSubscriptionIntervalUnit,
-  ZRBTenantSubscriptionProjection,
-  ZRBTenantSubscriptionScope,
-  ZRBTenantSubscriptionStatus,
-  ZRBTenantSubscriptionType,
-  ZRBUploadChunk,
-  ZRBUploadSession,
-  ZRBUploadSessionStatus,
-  ZRBUser,
-  b as buildAbility,
-  a as buildAbilityFromSession,
-  b2 as buildLocaleFallbackChain,
-  buildSearchTextStage,
-  c as can,
-  createModels,
-  createTenantBillingStorage,
-  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
+var createTenantBillingStorage = (params) => {
+	const findExistingEvent = async (query, transaction) => {
+		const request = (await models.get("RBTenantSubscriptionEvent", params.ctx)).findOne(query);
+		const session = getTransactionSession(transaction);
+		if (session) request.session(session);
+		const document = await request.lean();
+		return document ? toSubscriptionEvent(document) : null;
+	};
+	return {
+		runInTransaction: (operation) => withTransaction({ ctx: params.ctx }, ({ session }) => operation({ session })),
+		createEvent: async (event, transaction) => {
+			if (event.tenantId !== params.tenantId) throw new Error("Billing event tenantId does not match the storage tenant");
+			const existingQuery = getExistingEventQuery(event, params.tenantId);
+			const existing = await findExistingEvent(existingQuery, transaction);
+			if (existing) return existing;
+			const EventModel = await models.get("RBTenantSubscriptionEvent", params.ctx);
+			const eventDocument = ZRBTenantSubscriptionEvent.parse(event);
+			const session = getTransactionSession(transaction);
+			try {
+				const document = (await EventModel.create([eventDocument], session ? { session } : void 0))[0]?.toObject();
+				if (!document) throw new Error("Subscription event was not persisted");
+				return toSubscriptionEvent(document);
+			} catch (error) {
+				if (!isDuplicateKeyError(error)) throw error;
+				const duplicate = await findExistingEvent(existingQuery, transaction);
+				if (!duplicate) throw error;
+				return duplicate;
+			}
+		},
+		listEvents: async (tenantId, subscriptionId, transaction) => {
+			if (tenantId !== params.tenantId) throw new Error("Billing storage tenant mismatch");
+			const request = (await models.get("RBTenantSubscriptionEvent", params.ctx)).find({
+				tenantId,
+				subscriptionId
+			}).sort({
+				effectiveAt: 1,
+				occurredAt: 1,
+				_id: 1
+			});
+			const session = getTransactionSession(transaction);
+			if (session) request.session(session);
+			return (await request.lean()).map(toSubscriptionEvent);
+		},
+		upsertProjection: async (projection, transaction) => {
+			if (projection.tenantId !== params.tenantId) throw new Error("Billing projection tenant mismatch");
+			const ProjectionModel = await models.get("RBTenantSubscriptionProjection", params.ctx);
+			const session = getTransactionSession(transaction);
+			await ProjectionModel.replaceOne({
+				tenantId: params.tenantId,
+				subscriptionId: projection.subscriptionId
+			}, toProjectionDocument(projection), {
+				upsert: true,
+				runValidators: true,
+				...session ? { session } : {}
+			});
+		}
+	};
+};
+//#endregion
+export { E164_PHONE_OR_EMPTY_REGEX, E164_PHONE_REGEX, LANGUAGE_CODE_REGEX, PaginationValidationError, RBNotificationDeliveryPolicy, RBNotificationDeliverySchema, RBNotificationPolicy, RBNotificationSchema, RBNotificationSettingsPolicy, RBNotificationSettingsSchema, RBOAuthRequestSchema, RBRtsChangeSchema, RBRtsCounterSchema, RBTenantSchema, RBTenantSubscriptionEventSchema, RBTenantSubscriptionProjectionSchema, RBUploadChunkSchema, RBUploadSessionPolicy, RBUploadSessionSchema, RBUserSchema, Schema, ZRBNotification, ZRBNotificationDelivery, ZRBNotificationDigestFrequency, ZRBNotificationPlatformPayload, ZRBNotificationSettings, ZRBNotificationTopicPreference, ZRBOAuthRequest, ZRBRtsChange, ZRBRtsChangeOp, ZRBRtsCounter, ZRBTenant, ZRBTenantSubscriptionChangeDirection, ZRBTenantSubscriptionEvent, ZRBTenantSubscriptionEventSource, ZRBTenantSubscriptionEventType, ZRBTenantSubscriptionIntervalUnit, ZRBTenantSubscriptionProjection, ZRBTenantSubscriptionScope, ZRBTenantSubscriptionStatus, ZRBTenantSubscriptionType, ZRBUploadChunk, ZRBUploadSession, ZRBUploadSessionStatus, ZRBUser, buildAbility, buildAbilityFromSession, buildLocaleFallbackChain, buildSearchTextStage, can, createModels, createTenantBillingStorage, 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