@classytic/mongokit 3.43.1 → 3.45.0

package/dist/sync/index.mjs

@@ -1,8 +1,27 @@
-import { o as withTransaction } from "../transaction-DmiB4k2P.mjs";
+import { o as withTransaction } from "../transaction-C6Oj941P.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,99 @@ 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
+	});
+	/**
+	* The entry a reader of one document ends on, which retention keeps. A tombstone applies
+	* unconditionally (`changeLogPlugin` writes version 0); an upsert only above the version held. So:
+	* the last tombstone, unless upserts follow it, then the highest of those (the first on a tie).
+	* Not simply the last cursor: branch stock records a lower version after a higher one.
+	*/
+	const winnerOf = (rows) => {
+		let held = null;
+		for (const row of [...rows].sort((a, b) => a.seq - b.seq)) if (row.op === "delete") held = {
+			seq: row.seq,
+			version: Number.NEGATIVE_INFINITY
+		};
+		else if (!held || row.version > held.version) held = {
+			seq: row.seq,
+			version: row.version
+		};
+		return held?.seq ?? 0;
+	};
+	const winnerSeq = async (filter) => {
+		const tomb = await entries.findOne({
+			...filter,
+			op: "delete"
+		}).sort({ seq: -1 }).select({ seq: 1 }).lean().exec();
+		const bound = filter.seq ?? {};
+		return (await entries.findOne(tomb?.seq === void 0 ? {
+			...filter,
+			op: "upsert"
+		} : {
+			...filter,
+			op: "upsert",
+			seq: {
+				...bound,
+				$gt: tomb.seq
+			}
+		}).sort({
+			version: -1,
+			seq: 1
+		}).select({ seq: 1 }).lean().exec())?.seq ?? tomb?.seq ?? 0;
+	};
 	const toEntry = (row) => ({
 		scope: row.scope,
 		docId: row.docId,
@@ -254,12 +450,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 +463,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 +482,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 +502,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,24 +514,42 @@ 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"
-					},
-					latest: { $max: "$seq" },
+					_id: docKey,
+					top: { $max: "$seq" },
 					n: { $sum: 1 }
 				} },
 				{ $match: { n: { $gt: 1 } } },
-				{ $project: { latest: 1 } }
+				{ $project: { top: 1 } }
 			]).allowDiskUse(true).cursor({ batchSize });
 			let removed = 0;
 			let ops = [];
@@ -341,15 +559,154 @@ function createChangeLogStore(models) {
 				ops = [];
 			};
 			for await (const g of groups) {
+				const doc = docOf(g._id);
+				const keep = await winnerSeq({
+					...doc,
+					seq: { $lte: g.top }
+				});
 				ops.push({ deleteMany: { filter: {
-					scope: g._id.scope,
-					docId: g._id.docId,
-					seq: { $lt: g.latest }
+					...doc,
+					seq: {
+						$lte: g.top,
+						$ne: keep
+					}
 				} } });
 				if (ops.length >= batchSize) await flush();
 			}
 			await flush();
 			return { removed };
+		},
+		async horizon(options) {
+			const seq = await horizonFor(options);
+			return seq > 0 ? toCursor(seq) : "";
+		},
+		async snapshot(cursor, options = {}) {
+			const { upTo: bound, ...view } = options;
+			const limit = view.limit ?? DEFAULT_LIMIT;
+			const upTo = bound === void 0 ? await horizonFor(view) : fromCursor(bound);
+			const after = fromCursor(cursor);
+			const upToCursor = upTo > 0 ? toCursor(upTo) : "";
+			if (after >= upTo) return {
+				changes: [],
+				cursor,
+				hasMore: false,
+				upTo: upToCursor
+			};
+			const rows = await entries.find({
+				seq: {
+					$gt: after,
+					$lte: upTo
+				},
+				...viewOf(view)
+			}).sort({ seq: 1 }).limit(limit + 1).lean().exec();
+			const page = rows.slice(0, limit);
+			const latest = /* @__PURE__ */ new Map();
+			if (page.length > 0) {
+				const keyOf = (r) => JSON.stringify([
+					typeof r.tenantId === "string" ? r.tenantId : null,
+					r.scope,
+					r.docId
+				]);
+				const docs = new Map(page.map((r) => [keyOf(r), r]));
+				const groups = await entries.aggregate([{ $match: {
+					seq: { $lte: upTo },
+					$or: [...docs.values()].map((r) => docOf({
+						tenantId: typeof r.tenantId === "string" ? r.tenantId : null,
+						scope: r.scope,
+						docId: r.docId
+					}))
+				} }, { $group: {
+					_id: docKey,
+					rows: { $push: {
+						seq: "$seq",
+						version: "$version",
+						op: "$op"
+					} }
+				} }]).allowDiskUse(true).exec();
+				for (const g of groups) latest.set(keyOf(g._id), winnerOf(g.rows));
+				const changes = page.filter((r) => latest.get(keyOf(r)) === r.seq && r.op === "upsert").map(toEntry);
+				const last = page[page.length - 1];
+				return {
+					changes,
+					cursor: toCursor(last.seq),
+					hasMore: rows.length > limit,
+					upTo: upToCursor
+				};
+			}
+			return {
+				changes: [],
+				cursor,
+				hasMore: false,
+				upTo: upToCursor
+			};
+		},
+		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 keep = await winnerSeq(doc);
+				const deletedMax = await topSeq({
+					...doc,
+					at: old,
+					seq: {
+						$lte: g.oldMax,
+						$ne: keep
+					}
+				});
+				if (deletedMax <= 0) continue;
+				ops.push({ deleteMany: { filter: {
+					...doc,
+					at: old,
+					seq: {
+						$lte: deletedMax,
+						$ne: keep
+					}
+				} } });
+				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 +899,4 @@ function createCommandStreamStore(connection, models, changes) {
 		}
 	};
 }
-//#endregion
-export { createChangeLogModels, createChangeLogStore, createCommandStreamModels, createCommandStreamStore };
+export { DEFAULT_SEQUENCER_LEASE_MS, createChangeLogModels, createChangeLogStore, createCommandStreamModels, createCommandStreamStore };