@classytic/mongokit 3.43.0 → 3.44.0

package/dist/sync/index.mjs

@@ -1,8 +1,27 @@
-import { o as withTransaction } from "../transaction-DmiB4k2P.mjs";
+import { o as withTransaction } from "../transaction-C2PFxfIv.mjs";
 import { Schema, Types } from "mongoose";
-//#region src/sync/index.ts
+import { CursorExpiredError } from "@classytic/repo-core/sync";
+// src/sync/index.ts
+/**
+* The mongo stores behind `@classytic/repo-core/sync` (replica set): the change feed
+* (`createChangeLogStore`, filled by `changeLogPlugin`) and the command streams
+* (`createCommandStreamStore`) a sync engine such as `@classytic/arc-sync` records verdicts in.
+* Proven by `runChangeLogStoreConformance` and `runCommandStreamStoreConformance`.
+*
+* ```ts
+* const changes = createChangeLogStore(createChangeLogModels(connection));
+* const streams = createCommandStreamStore(connection, createCommandStreamModels(connection), changes);
+* ```
+*
+* Feed cursors are a gap-free sequence taken from ONE counter document inside the caller's
+* transaction, so sequence order IS commit order: no reader can checkpoint past an entry that has
+* not committed yet. The single counter caps append throughput — the price of never losing an entry.
+*/
+/** Default deferred-sequencer lease: a crashed holder delays numbering at most this long. */
+const DEFAULT_SEQUENCER_LEASE_MS = 5e3;
 function createChangeLogModels(connection, options = {}) {
-	const { collection = "sync_changes", modelName = "SyncChange", sequencing = "in-transaction" } = options;
+	const { collection = "sync_changes", modelName = "SyncChange", sequencing = "in-transaction", sequencerLeaseMs = DEFAULT_SEQUENCER_LEASE_MS } = options;
+	assertLeaseMs(sequencerLeaseMs);
 	const entriesName = modelName;
 	const counterName = `${modelName}Counter`;
 	const entries = connection.models[entriesName] ?? connection.model(entriesName, (() => {
@@ -60,6 +79,7 @@ function createChangeLogModels(connection, options = {}) {
 			docId: 1,
 			seq: 1
 		}, { name: "doc_versions" });
+		schema.index({ at: 1 }, { name: "feed_age" });
 		return schema;
 	})());
 	const counter = connection.models[counterName] ?? connection.model(counterName, new Schema({
@@ -73,11 +93,42 @@ function createChangeLogModels(connection, options = {}) {
 		},
 		/** The deferred sequencer's lease. */
 		lockUntil: { type: Date },
-		lockBy: { type: String }
+		lockBy: { type: String },
+		/** `prune`'s feed-wide horizon: the highest seq it deleted. An unfiltered cursor below it is expired. */
+		horizon: { type: Number }
 	}, {
 		collection: `${collection}_counter`,
 		versionKey: false
 	}));
+	const horizonName = `${modelName}Horizon`;
+	const horizons = connection.models[horizonName] ?? connection.model(horizonName, (() => {
+		const schema = new Schema({
+			tenantId: {
+				type: String,
+				default: null
+			},
+			scope: {
+				type: String,
+				required: true
+			},
+			horizon: {
+				type: Number,
+				required: true
+			}
+		}, {
+			collection: `${collection}_horizon`,
+			versionKey: false
+		});
+		schema.index({
+			tenantId: 1,
+			scope: 1
+		}, {
+			unique: true,
+			name: "tenant_scope_horizon"
+		});
+		schema.index({ scope: 1 }, { name: "scope_horizon" });
+		return schema;
+	})());
 	const pendingName = `${modelName}Pending`;
 	const pending = sequencing === "deferred" ? connection.models[pendingName] ?? connection.model(pendingName, new Schema({
 		scope: {
@@ -111,11 +162,16 @@ function createChangeLogModels(connection, options = {}) {
 	return {
 		entries,
 		counter,
+		horizons,
 		...pending ? { pending } : {},
 		sequencing,
+		sequencerLeaseMs,
 		feed: collection
 	};
 }
+function assertLeaseMs(ms) {
+	if (typeof ms !== "number" || !Number.isInteger(ms) || ms < 100) throw new Error("[mongokit:sync] sequencerLeaseMs must be an integer of at least 100");
+}
 /** A change as staged under deferred sequencing — the feed row without its `seq`. */
 function stagedRow(entry, at) {
 	return {
@@ -137,36 +193,81 @@ const fromCursor = (cursor) => {
 	return seq;
 };
 const DEFAULT_LIMIT = 500;
-/** How long one sequencer holds the lease — far above one batch, so a live holder never loses it mid-batch. */
-const SEQUENCER_LEASE_MS = 3e4;
 const SEQUENCER_BATCH = 500;
-function createChangeLogStore(models) {
-	const { entries, counter, feed, pending } = models;
+/** Thrown inside a batch transaction whose lease was taken over: the transaction aborts, nothing it wrote lands. */
+var SequencerLeaseLost = class extends Error {};
+function createChangeLogStore(models, storeOptions = {}) {
+	const { entries, counter, feed, pending, horizons } = models;
 	const deferred = models.sequencing === "deferred" && pending !== void 0;
+	const leaseMs = models.sequencerLeaseMs ?? 5e3;
+	assertLeaseMs(leaseMs);
+	const now = storeOptions.now ?? (() => /* @__PURE__ */ new Date());
+	const onSequenced = storeOptions.onSequenced;
+	const counterId = feed;
+	const report = (event) => {
+		try {
+			onSequenced?.(event);
+		} catch {}
+	};
+	/** The feed's numbered top (the counter row's `seq`; 0 before the first entry). */
+	const counterTop = async () => {
+		const row = await counter.collection.findOne({ _id: counterId }, { projection: { seq: 1 } });
+		return typeof row?.seq === "number" ? row.seq : 0;
+	};
+	/**
+	* After a pass found the lease busy (and a hook is set): retry in the background until the holder is done, then
+	* report what got numbered meanwhile. One follow-up per store at a time; bounded by three leases.
+	*/
+	let followUp = false;
+	const followBusyLease = async () => {
+		if (!onSequenced || followUp) return;
+		followUp = true;
+		try {
+			const seen = await counterTop();
+			const deadline = Date.now() + leaseMs * 3;
+			let delay = Math.max(10, Math.min(50, Math.floor(leaseMs / 10)));
+			for (;;) {
+				await new Promise((r) => {
+					setTimeout(r, delay).unref?.();
+				});
+				const result = await runPass();
+				if (result !== null) {
+					if (result === 0) {
+						const top = await counterTop();
+						if (top > seen) report({
+							cursor: toCursor(top),
+							numbered: top - seen,
+							by: "other"
+						});
+					}
+					return;
+				}
+				if (Date.now() > deadline) return;
+				delay = Math.min(delay * 2, Math.max(50, Math.floor(leaseMs / 2)));
+			}
+		} catch {} finally {
+			followUp = false;
+		}
+	};
 	/**
 	* One pass under the lease: committed staged rows → the feed, in staging order, numbered above everything.
-	* Nothing staged costs ONE read. A crash mid-pass is converged by the next one: an entry already in the feed is
-	* recognised by its unique `pendingId`, and a stale counter is caught by the unique `seq` index.
+	* Nothing staged costs ONE read. The lease lives on the counter row and is judged on the database clock; each
+	* batch commits in ONE transaction (insert, counter + lease renewal gated on this pass's token, staged-row delete),
+	* so a holder that lost the lease to a takeover writes nothing, and a crash leaves no half batch. Without
+	* transactions (standalone) the batch runs unfenced, as before. A pre-existing half batch is still converged:
+	* an entry already in the feed is recognised by its unique `pendingId`, a stale counter by the unique `seq` index.
 	*/
-	const sequencePending = async () => {
+	const runPass = async () => {
 		if (!deferred || !pending) return 0;
 		if (!await pending.exists({}).exec()) return 0;
 		const token = new Types.ObjectId().toString();
-		const unlocked = {
-			_id: feed,
-			$or: [
-				{ lockUntil: { $exists: false } },
-				{ lockUntil: null },
-				{ lockUntil: { $lt: /* @__PURE__ */ new Date() } }
-			]
-		};
-		const takeLease = () => counter.findOneAndUpdate(unlocked, { $set: {
-			lockUntil: new Date(Date.now() + SEQUENCER_LEASE_MS),
-			lockBy: token
-		} }, {
-			returnDocument: "after",
-			lean: true
-		}).exec();
+		const takeLease = async () => await counter.collection.findOneAndUpdate({
+			_id: counterId,
+			$expr: { $lt: ["$lockUntil", "$$NOW"] }
+		}, [{ $set: {
+			lockUntil: { $add: ["$$NOW", leaseMs] },
+			lockBy: { $literal: token }
+		} }], { returnDocument: "after" });
 		let lease = await takeLease();
 		if (!lease) {
 			if (await counter.exists({ _id: feed }).exec()) return null;
@@ -181,39 +282,53 @@ function createChangeLogStore(models) {
 		}
 		let seq = lease.seq ?? 0;
 		let numbered = 0;
+		const build = (from, list) => list.map((r, i) => {
+			const { _id, ...rest } = r;
+			return {
+				...rest,
+				seq: from + i + 1,
+				pendingId: String(_id)
+			};
+		});
+		/** Commit one batch atomically under the lease; `fresh` are the rows not yet in the feed. */
+		const commit = (rows, fresh) => withTransaction(entries.db, async (session) => {
+			if (fresh.length > 0) await entries.insertMany(build(seq, fresh), {
+				ordered: true,
+				session
+			});
+			if ((await counter.collection.updateOne({
+				_id: counterId,
+				lockBy: token
+			}, [{ $set: {
+				seq: { $max: ["$seq", seq + fresh.length] },
+				lockUntil: { $add: ["$$NOW", leaseMs] }
+			} }], { session })).matchedCount === 0) throw new SequencerLeaseLost();
+			await pending.deleteMany({ _id: { $in: rows.map((r) => r._id) } }, { session }).exec();
+		}, { allowFallback: true });
 		try {
 			for (;;) {
 				const rows = await pending.find({}).sort({ _id: 1 }).limit(SEQUENCER_BATCH).lean().exec();
 				if (rows.length === 0) break;
-				const build = (from, list) => list.map((r, i) => {
-					const { _id, ...rest } = r;
-					return {
-						...rest,
-						seq: from + i + 1,
-						pendingId: String(_id)
-					};
-				});
 				try {
-					await entries.insertMany(build(seq, rows), { ordered: true });
+					await commit(rows, rows);
 					seq += rows.length;
 					numbered += rows.length;
 				} catch (err) {
+					if (err instanceof SequencerLeaseLost) break;
 					if (err.code !== 11e3) throw err;
 					const placed = new Set((await entries.find({ pendingId: { $in: rows.map((r) => String(r._id)) } }).select({ pendingId: 1 }).lean().exec()).map((e) => e.pendingId));
 					const fresh = rows.filter((r) => !placed.has(String(r._id)));
 					const top = await entries.findOne({}).sort({ seq: -1 }).select({ seq: 1 }).lean().exec();
 					seq = Math.max(seq, top?.seq ?? 0);
-					if (fresh.length > 0) {
-						await entries.insertMany(build(seq, fresh), { ordered: true });
-						seq += fresh.length;
-						numbered += fresh.length;
+					try {
+						await commit(rows, fresh);
+					} catch (again) {
+						if (again instanceof SequencerLeaseLost) break;
+						throw again;
 					}
+					seq += fresh.length;
+					numbered += fresh.length;
 				}
-				await counter.updateOne({
-					_id: feed,
-					lockBy: token
-				}, { $max: { seq } }).exec();
-				await pending.deleteMany({ _id: { $in: rows.map((r) => r._id) } }).exec();
 				if (rows.length < SEQUENCER_BATCH) break;
 			}
 		} finally {
@@ -225,18 +340,60 @@ function createChangeLogStore(models) {
 				lockBy: null
 			} }).exec();
 		}
+		if (numbered > 0) report({
+			cursor: toCursor(seq),
+			numbered,
+			by: "self"
+		});
 		return numbered;
 	};
+	/** One pass; a busy lease starts the background follow-up (only with `onSequenced`). */
+	const sequencePending = async () => {
+		const result = await runPass();
+		if (result === null) followBusyLease();
+		return result;
+	};
 	const sessionOf = (options) => options?.session ? { session: options.session } : {};
-	const filterOf = (after, options = {}) => {
+	/** What a reader sees: its tenant (plus shared scopes), narrowed by `scopes`. Matches entries and horizon rows. */
+	const viewOf = (options = {}) => {
 		const { tenantId, scopes, sharedScopes } = options;
-		const tenant = tenantId === void 0 ? {} : sharedScopes?.length ? { $or: [{ tenantId }, { scope: { $in: [...sharedScopes] } }] } : { tenantId };
 		return {
-			seq: { $gt: after },
-			...tenant,
+			...tenantId === void 0 ? {} : sharedScopes?.length ? { $or: [{ tenantId }, { scope: { $in: [...sharedScopes] } }] } : { tenantId },
 			...scopes ? { scope: { $in: [...scopes] } } : {}
 		};
 	};
+	const filterOf = (after, options = {}) => ({
+		seq: { $gt: after },
+		...viewOf(options)
+	});
+	/** The recorded feed-wide compaction horizon (0: never pruned). Raw driver: the counter row is schemaless here. */
+	const horizonSeq = async () => {
+		const row = await counter.collection.findOne({ _id: feed }, { projection: { horizon: 1 } });
+		return typeof row?.horizon === "number" ? row.horizon : 0;
+	};
+	/** The horizon a reader is held to: the highest one among the `(tenantId, scope)` rows it can see. */
+	const horizonFor = async (options = {}) => {
+		if (!horizons || options.tenantId === void 0 && !options.scopes) return horizonSeq();
+		const row = await horizons.collection.findOne(viewOf(options), {
+			sort: { horizon: -1 },
+			projection: { horizon: 1 }
+		});
+		return typeof row?.horizon === "number" ? row.horizon : 0;
+	};
+	/**
+	* One document's identity: tenants sharing a docId in one scope are different documents. A missing
+	* tenantId groups (and, as `null`, matches) as untenanted.
+	*/
+	const docKey = {
+		tenantId: { $ifNull: ["$tenantId", null] },
+		scope: "$scope",
+		docId: "$docId"
+	};
+	const docOf = (id) => ({
+		tenantId: id.tenantId ?? null,
+		scope: id.scope,
+		docId: id.docId
+	});
 	const toEntry = (row) => ({
 		scope: row.scope,
 		docId: row.docId,
@@ -254,12 +411,12 @@ function createChangeLogStore(models) {
 				await this.append(entry, options);
 				return;
 			}
-			await pending.create([stagedRow(entry, /* @__PURE__ */ new Date())], sessionOf(options));
+			await pending.create([stagedRow(entry, now())], sessionOf(options));
 		},
 		async append(entry, options) {
 			const session = sessionOf(options);
 			if (deferred && pending) {
-				const at = /* @__PURE__ */ new Date();
+				const at = now();
 				const [staged] = await pending.create([stagedRow(entry, at)], session);
 				if (options?.session) return {
 					...entry,
@@ -267,7 +424,8 @@ function createChangeLogStore(models) {
 					cursor: ""
 				};
 				const stagedId = String(staged?._id);
-				for (let attempt = 0; attempt < 50; attempt++) {
+				const deadline = Date.now() + Math.max(1e3, leaseMs + 1e3);
+				for (let attempt = 0; attempt < 50 || Date.now() < deadline; attempt++) {
 					await sequencePending();
 					const at2 = await entries.findOne({ pendingId: stagedId }).select({ seq: 1 }).lean().exec();
 					if (typeof at2?.seq === "number") return {
@@ -285,7 +443,7 @@ function createChangeLogStore(models) {
 				lean: true,
 				...session
 			}).exec()).seq;
-			const at = /* @__PURE__ */ new Date();
+			const at = now();
 			await entries.create([{
 				seq,
 				scope: entry.scope,
@@ -305,7 +463,10 @@ function createChangeLogStore(models) {
 		async since(cursor, options = {}) {
 			if (deferred) await sequencePending();
 			const limit = options.limit ?? DEFAULT_LIMIT;
-			const rows = await entries.find(filterOf(fromCursor(cursor), options)).sort({ seq: 1 }).limit(limit + 1).lean().exec();
+			const after = fromCursor(cursor);
+			const rows = await entries.find(filterOf(after, options)).sort({ seq: 1 }).limit(limit + 1).lean().exec();
+			const horizon = await horizonFor(options);
+			if (horizon > 0 && after < horizon) throw new CursorExpiredError(cursor, toCursor(horizon));
 			const page = rows.slice(0, limit).map(toEntry);
 			const last = page[page.length - 1];
 			return {
@@ -314,19 +475,37 @@ function createChangeLogStore(models) {
 				hasMore: rows.length > limit
 			};
 		},
+		async latestOf(scope, docId, options = {}) {
+			const filter = {
+				scope,
+				docId,
+				tenantId: options.tenantId ?? null
+			};
+			const session = options.session ? { session: options.session } : {};
+			if (deferred && pending) {
+				const staged = await pending.findOne(filter, null, session).sort({ _id: -1 }).lean().exec();
+				if (staged) return {
+					...toEntry({
+						...staged,
+						seq: 0
+					}),
+					cursor: ""
+				};
+			}
+			const row = await entries.findOne(filter, null, session).sort({ seq: -1 }).lean().exec();
+			return row ? toEntry(row) : null;
+		},
 		async latestCursor(options = {}) {
 			if (deferred) await sequencePending();
 			const row = await entries.findOne(filterOf(0, options)).sort({ seq: -1 }).select({ seq: 1 }).lean().exec();
-			return row?.seq ? toCursor(row.seq) : "";
+			const seq = Math.max(row?.seq ?? 0, await horizonFor(options));
+			return seq > 0 ? toCursor(seq) : "";
 		},
 		async compactSuperseded(options = {}) {
 			const batchSize = options.batchSize ?? 1e3;
 			const groups = entries.aggregate([
 				{ $group: {
-					_id: {
-						scope: "$scope",
-						docId: "$docId"
-					},
+					_id: docKey,
 					latest: { $max: "$seq" },
 					n: { $sum: 1 }
 				} },
@@ -342,14 +521,82 @@ function createChangeLogStore(models) {
 			};
 			for await (const g of groups) {
 				ops.push({ deleteMany: { filter: {
-					scope: g._id.scope,
-					docId: g._id.docId,
+					...docOf(g._id),
 					seq: { $lt: g.latest }
 				} } });
 				if (ops.length >= batchSize) await flush();
 			}
 			await flush();
 			return { removed };
+		},
+		async horizon(options) {
+			const seq = await horizonFor(options);
+			return seq > 0 ? toCursor(seq) : "";
+		},
+		async prune(before, options = {}) {
+			if (!(before instanceof Date) || Number.isNaN(before.getTime())) throw new Error("[mongokit:sync] prune(before) needs a valid Date");
+			const batchSize = options.batchSize ?? 1e3;
+			if (!Number.isInteger(batchSize) || batchSize < 1) throw new Error("[mongokit:sync] prune batchSize must be a positive integer");
+			if (deferred) await sequencePending();
+			const old = { $lt: before };
+			const groups = entries.aggregate([{ $match: { at: old } }, { $group: {
+				_id: docKey,
+				oldMax: { $max: "$seq" },
+				n: { $sum: 1 }
+			} }]).allowDiskUse(true).cursor({ batchSize });
+			const topSeq = async (filter) => {
+				return (await entries.findOne(filter).sort({ seq: -1 }).select({ seq: 1 }).lean().exec())?.seq ?? 0;
+			};
+			let ops = [];
+			let batchMax = 0;
+			/** Highest seq this batch deletes per `(tenantId, scope)` — the rows a filtered reader is held to. */
+			let viewMax = /* @__PURE__ */ new Map();
+			const flush = async () => {
+				if (ops.length === 0) return;
+				if (horizons) await horizons.collection.bulkWrite([...viewMax.values()].map(({ tenantId, scope, seq }) => ({ updateOne: {
+					filter: {
+						tenantId,
+						scope
+					},
+					update: { $max: { horizon: seq } },
+					upsert: true
+				} })), { ordered: false });
+				await counter.collection.updateOne({ _id: feed }, { $max: { horizon: batchMax } }, { upsert: true });
+				await entries.bulkWrite(ops, { ordered: false });
+				ops = [];
+				batchMax = 0;
+				viewMax = /* @__PURE__ */ new Map();
+			};
+			for await (const g of groups) {
+				const doc = docOf(g._id);
+				const latest = await topSeq(doc);
+				let deletedMax;
+				if (latest > g.oldMax) deletedMax = g.oldMax;
+				else if (g.n > 1) deletedMax = await topSeq({
+					...doc,
+					at: old,
+					seq: { $lt: latest }
+				});
+				else continue;
+				if (deletedMax <= 0) continue;
+				ops.push({ deleteMany: { filter: {
+					...doc,
+					at: old,
+					seq: { $lte: deletedMax }
+				} } });
+				batchMax = Math.max(batchMax, deletedMax);
+				const key = JSON.stringify([doc.tenantId, doc.scope]);
+				const seen = viewMax.get(key);
+				if (!seen || seen.seq < deletedMax) viewMax.set(key, {
+					tenantId: doc.tenantId,
+					scope: doc.scope,
+					seq: deletedMax
+				});
+				if (ops.length >= batchSize) await flush();
+			}
+			await flush();
+			const horizon = await horizonSeq();
+			return horizon > 0 ? toCursor(horizon) : "";
 		}
 	};
 }
@@ -542,5 +789,4 @@ function createCommandStreamStore(connection, models, changes) {
 		}
 	};
 }
-//#endregion
-export { createChangeLogModels, createChangeLogStore, createCommandStreamModels, createCommandStreamStore };
+export { DEFAULT_SEQUENCER_LEASE_MS, createChangeLogModels, createChangeLogStore, createCommandStreamModels, createCommandStreamStore };

package/dist/tenant/index.d.mts

@@ -1,15 +1,14 @@
 import { Schema } from "mongoose";
 import { ResolvedTenantConfig } from "@classytic/repo-core/tenant";
-//#region src/tenant/index.d.ts
 /** Which read an index serves. Default `'tenant'`. See the module docblock. */
-type IndexScope = 'tenant' | 'global';
+export type IndexScope = 'tenant' | 'global';
 /** Key directions and types a declaration may use. Mirrors what `schema.index()` accepts. */
-type IndexKeyValue = 1 | -1 | 'text' | '2dsphere' | '2d' | 'hashed';
+export type IndexKeyValue = 1 | -1 | 'text' | '2dsphere' | '2d' | 'hashed';
 /**
  * Index options passed through to `schema.index()`. `name` is the only one this module
  * reads (to apply and to explain exemptions); everything else is Mongoose's.
  */
-interface IndexDeclarationOptions {
+export interface IndexDeclarationOptions {
   name?: string | undefined;
   unique?: boolean | undefined;
   sparse?: boolean | undefined;
@@ -25,13 +24,13 @@ interface IndexDeclarationOptions {
  * makes `scope` mean something: a `'tenant'` declaration is prefixed exactly like the
  * kernel's own indexes, a `'global'` one is kept as written.
  */
-interface IndexDeclaration {
+export interface IndexDeclaration {
   readonly fields: Readonly<Record<string, IndexKeyValue>>;
   readonly options?: IndexDeclarationOptions | undefined;
   /** @default 'tenant' */
   readonly scope?: IndexScope | undefined;
 }
-interface InjectTenantFieldOptions {
+export interface InjectTenantFieldOptions {
   /**
    * Index NAMES (the `name` option of `schema.index()`) already on the schema whose key
    * spec must NOT get the tenant prefix. The escape hatch for a kernel's OWN global
@@ -53,7 +52,7 @@ interface InjectTenantFieldOptions {
  * so a bad host config fails at DESCRIBE time, with the fix in the message, rather than
  * building a wrong index on the first bind.
  */
-declare function assertIndexDeclaration(declaration: IndexDeclaration, tenant: Pick<ResolvedTenantConfig, 'tenantField'>): void;
+export declare function assertIndexDeclaration(declaration: IndexDeclaration, tenant: Pick<ResolvedTenantConfig, 'tenantField'>): void;
 /**
  * Add `declarations` to `schema` honouring each one's scope.
  *
@@ -65,7 +64,7 @@ declare function assertIndexDeclaration(declaration: IndexDeclaration, tenant: P
  * Exported for kernels whose optional models inject the tenant field on their own path and
  * only need the host's extra declarations applied afterwards.
  */
-declare function declareIndexes(schema: Schema, tenant: ResolvedTenantConfig, declarations: readonly IndexDeclaration[] | undefined): void;
+export declare function declareIndexes(schema: Schema, tenant: ResolvedTenantConfig, declarations: readonly IndexDeclaration[] | undefined): void;
 /**
  * Inject the tenant field into a Mongoose schema and make its indexes tenant-correct.
  *
@@ -84,6 +83,4 @@ declare function declareIndexes(schema: Schema, tenant: ResolvedTenantConfig, de
  *    insert (PACKAGE_RULES P11.1; the fleet index audit found this pattern behind most of
  *    86 redundant indexes across 615).
  */
-declare function injectTenantField(schema: Schema, tenant: ResolvedTenantConfig, options?: InjectTenantFieldOptions): void;
-//#endregion
-export { IndexDeclaration, IndexDeclarationOptions, IndexKeyValue, IndexScope, InjectTenantFieldOptions, assertIndexDeclaration, declareIndexes, injectTenantField };
+export declare function injectTenantField(schema: Schema, tenant: ResolvedTenantConfig, options?: InjectTenantFieldOptions): void;

package/dist/tenant/index.mjs

@@ -1,5 +1,5 @@
 import mongoose from "mongoose";
-//#region src/tenant/index.ts
+// src/tenant/index.ts
 /** Mongoose keeps declared indexes on `schema._indexes`; `schema.indexes()` is a copy. */
 function indexEntries(schema) {
 	return schema._indexes ?? [];
@@ -92,5 +92,4 @@ function injectTenantField(schema, tenant, options = {}) {
 	declareIndexes(schema, tenant, options.indexes);
 	if (!indexEntries(schema).some(([fields]) => Object.keys(fields)[0] === tenant.tenantField)) schema.index({ [tenant.tenantField]: 1 });
 }
-//#endregion
 export { assertIndexDeclaration, declareIndexes, injectTenantField };